packages feed

fei-base (empty) → 0.2.0.0

raw patch · 25 files changed

+129820/−0 lines, 25 filesdep +basedep +c2hs-extradep +constraints

Dependencies added: base, c2hs-extra, constraints, directory, fei-base, filepath, haskell-src-exts, hslogger, mtl, optparse-applicative, repa, text, tuple-ops, vector

Files

+ LICENSE view
@@ -0,0 +1,30 @@+Copyright Jiasen Wu (c) 2018++All rights reserved.++Redistribution and use in source and binary forms, with or without+modification, are permitted provided that the following conditions are met:++    * Redistributions of source code must retain the above copyright+      notice, this list of conditions and the following disclaimer.++    * Redistributions in binary form must reproduce the above+      copyright notice, this list of conditions and the following+      disclaimer in the documentation and/or other materials provided+      with the distribution.++    * Neither the name of Author name here nor the names of other+      contributors may be used to endorse or promote products derived+      from this software without specific prior written permission.++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ README.md view
@@ -0,0 +1,14 @@+# mxnet-hs+## 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>`++## 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-examples
+ c-apis/MXNet/Base.hs view
@@ -0,0 +1,17 @@+module MXNet.Base(+    module MXNet.Base.Types,+    module MXNet.Base.Raw,+    module MXNet.Base.Symbol,+    module MXNet.Base.NDArray,+    module MXNet.Base.Executor,+    module MXNet.Base.Spec.HMap,+    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
+ c-apis/MXNet/Base/Executor.hs view
@@ -0,0 +1,10 @@+module MXNet.Base.Executor where++import qualified MXNet.Base.Raw as I+import MXNet.Base.Types (ForeignData(..))+++newtype Executor a = Executor { unExecutor :: I.ExecutorHandle }++instance ForeignData (Executor a) where+    touch = I.touchExecutorHandle . unExecutor
+ c-apis/MXNet/Base/NDArray.hs view
@@ -0,0 +1,94 @@+{-# 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.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 qualified MXNet.Base.Raw as I+import MXNet.Base.Types (Context(..), contextCPU, DType(..), ForeignData(..))++newtype NDArray a = NDArray { unNDArray :: I.NDArrayHandle}++instance ForeignData (NDArray a) where+    touch = I.touchNDArrayHandle . unNDArray++makeEmptyNDArray :: forall a. DType a => [Int] -> Context -> IO (NDArray a)+makeEmptyNDArray shape ctx = do+    array <- I.mxNDArrayCreateEx 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 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)+        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++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++ones :: DType a => [Int] -> IO (NDArray a)+ones = full 1++zeros :: DType a => [Int] -> IO (NDArray a)+zeros = full 1++fromVector :: DType a => [Int] -> Vector a -> IO (NDArray a)+fromVector shape = makeNDArray shape contextCPU++copyFromVector :: DType a => NDArray a -> Vector a -> IO ()+copyFromVector arr vec = do+    sz <- ndsize arr+    if (sz /= V.length vec) +      then error ""+      else do+        V.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 arr repa = do+    let vec = UV.convert $ Repa.toUnboxed $ Repa.computeS repa+    copyFromVector arr vec++toVector :: DType a => NDArray a -> IO (Vector a)+toVector arr = do+    nlen <- ndsize arr+    mvec <- VMut.new nlen+    VMut.unsafeWith mvec $ \p -> I.mxNDArraySyncCopyToCPU (unNDArray arr) (castPtr p) nlen+    V.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+    vec <- toVector arr+    return $ Repa.fromUnboxed (Repa.shapeOfList (reverse shp)) (UV.convert vec)++context :: DType a => NDArray a -> IO Context+context (NDArray handle) = do+    cxt <- I.mxNDArrayGetContext handle+    return $ uncurry Context cxt++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 = I.mxNDArrayWaitAll
+ c-apis/MXNet/Base/Raw.hs view
@@ -0,0 +1,13 @@+module MXNet.Base.Raw (+    module MXNet.Base.Raw.Common,+    module MXNet.Base.Raw.NDArray,+    module MXNet.Base.Raw.Symbol,+    module MXNet.Base.Raw.Executor,+    module MXNet.Base.Raw.DataIter+) where++import MXNet.Base.Raw.Common+import MXNet.Base.Raw.NDArray+import MXNet.Base.Raw.Symbol+import MXNet.Base.Raw.Executor+import MXNet.Base.Raw.DataIter
+ c-apis/MXNet/Base/Raw/Common.chs view
@@ -0,0 +1,227 @@+module MXNet.Base.Raw.Common where++import Control.Exception.Base (Exception, throwIO)+import Data.Typeable (Typeable)+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.Ptr+import C2HS.C.Extra.Marshal (peekString, peekStringArray)+import GHC.Generics (Generic)+import Data.Word (Word64)++type MX_UINT  = C2HSImp.CUInt+type MX_CCHAR = C2HSImp.CChar++data MXNetError = MXNetError String+    deriving Typeable+instance Exception MXNetError++instance Show MXNetError where+    show (MXNetError msg) = "an error occurred in MXNet.\n" ++ msg++deriving instance Generic C2HSImp.CInt+deriving instance Generic C2HSImp.CUInt++checked :: 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+      else return ret++withStringArray :: [String] -> (Ptr (Ptr CChar) -> IO a) -> IO a+withStringArray strs act = go strs []+  where+    go [] all = withArray (reverse all) act+    go (s:ss) all = withCString s (go ss . (:all))++#include <mxnet/c_api.h>+#include <nnvm/c_api.h>++{#+fun MXGetVersion as mxGetVersion_+    {+        alloca- `CInt' peek*+    } -> `CInt'+#}++mxGetVersion :: IO Int+mxGetVersion = fromIntegral <$> checked mxGetVersion_++{#+fun MXListAllOpNames as mxListAllOpNames_+    {+        alloca- `MX_UINT' peek*,+        alloca- `Ptr (Ptr MX_CCHAR)' peek*+    } -> `CInt'+#}++mxListAllOpNames :: IO [String]+mxListAllOpNames = do+    (cnt, ptr) <- checked mxListAllOpNames_+    peekStringArray (fromIntegral cnt :: Int) ptr++{#+fun MXGetLastError as mxGetLastError+    {+    } -> `String'+#}++{#+pointer AtomicSymbolCreator newtype+#}++deriving instance Storable AtomicSymbolCreator++fromOpHandle :: OpHandle -> AtomicSymbolCreator+fromOpHandle (OpHandle ptr) = AtomicSymbolCreator (C2HSImp.castPtr ptr)++{#+fun MXSymbolListAtomicSymbolCreators as mxSymbolListAtomicSymbolCreators_+    {+        alloca- `MX_UINT' peek*,+        alloca- `Ptr AtomicSymbolCreator' peek*+    } -> `CInt'+#}++mxSymbolListAtomicSymbolCreators :: IO [AtomicSymbolCreator]+mxSymbolListAtomicSymbolCreators = do+    (cnt, ptr) <- checked $ mxSymbolListAtomicSymbolCreators_+    peekArray (fromIntegral cnt) ptr++mxSymbolGetAtomicSymbolCreatorAt :: Int -> IO AtomicSymbolCreator+mxSymbolGetAtomicSymbolCreatorAt idx = do+    (cnt, ptr) <- checked $ mxSymbolListAtomicSymbolCreators_+    peekElemOff ptr idx++{#+fun MXSymbolGetAtomicSymbolName as mxSymbolGetAtomicSymbolName_+    {+        `AtomicSymbolCreator',+        alloca- `String' peekString*+    } -> `CInt'+#}++mxSymbolGetAtomicSymbolName :: AtomicSymbolCreator -> IO String+mxSymbolGetAtomicSymbolName = checked . mxSymbolGetAtomicSymbolName_++{#+fun MXSymbolGetAtomicSymbolInfo as mxSymbolGetAtomicSymbolInfo_+    {+        `AtomicSymbolCreator',+        alloca- `String' peekString*,+        alloca- `String' peekString*,+        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*+    } -> `CInt'+#}++mxSymbolGetAtomicSymbolInfo :: AtomicSymbolCreator+                            -> IO (String,+                                   String,+                                   [String],+                                   [String],+                                   [String],+                                   String,+                                   String)+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+    return (name, desc, argname, argtype, argdesc, key_var_num_args, rettyp)++{#+fun MXNotifyShutdown as mxNotifyShutdown_+    {+    } -> `CInt'+#}++mxNotifyShutdown :: IO ()+mxNotifyShutdown = checked mxNotifyShutdown_++---------------------------------------------------+type NN_UINT  = C2HSImp.CUInt++{# pointer OpHandle newtype #}+deriving instance Storable OpHandle+deriving instance Generic  OpHandle++{# pointer GraphHandle newtype #}+deriving instance Storable GraphHandle+deriving instance Generic  GraphHandle++{#+fun NNListAllOpNames as nnListAllOpNames_+    {+        alloca- `NN_UINT' peek*,+        alloca- `Ptr (Ptr MX_CCHAR)' peek*+    } -> `CInt'+#}++nnListAllOpNames :: IO [String]+nnListAllOpNames = do+    (cnt, ptr) <- checked nnListAllOpNames_+    peekStringArray (fromIntegral cnt :: Int) ptr++{#+fun NNListUniqueOps as nnListUniqueOps_+    {+        alloca- `NN_UINT' peek*,+        alloca- `Ptr OpHandle' peek*+    } -> `CInt'+#}++nnListUniqueOps :: IO [OpHandle]+nnListUniqueOps = do+    (cnt, ptr) <- checked (nnListUniqueOps_ :: IO (CInt, NN_UINT, Ptr OpHandle))+    peekArray (fromIntegral cnt :: Int) (ptr :: Ptr OpHandle)++{#+fun NNGetOpHandle as nnGetOpHandle_+    {+        `String',+        alloca- `OpHandle' peek*+    } -> `CInt'+#}++nnGetOpHandle :: String -> IO OpHandle+nnGetOpHandle = checked . nnGetOpHandle_++{#+fun NNGetOpInfo as nnGetOpInfo_+    {+        `OpHandle',+        alloca- `String' peekString*,+        alloca- `String' peekString*,+        alloca- `NN_UINT' peek*,+        alloca- `Ptr (Ptr CChar)' peek*,+        alloca- `Ptr (Ptr CChar)' peek*,+        alloca- `Ptr (Ptr CChar)' peek*,+        alloca- `String' peekString*+    } -> `CInt'+#}++nnGetOpInfo :: OpHandle -> IO (String, String, [String], [String], [String], String)+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+    return (name, desc, arg_names, arg_types, arg_descs, ret_type)++{#+fun NNGetLastError as nnGetLastError+    {+    } -> `String'+#}
+ c-apis/MXNet/Base/Raw/DataIter.chs view
@@ -0,0 +1,182 @@+module MXNet.Base.Raw.DataIter where++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.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 #}++#include <mxnet/c_api.h>++{# typedef mx_uint MX_UINT#}+{# default in `MX_UINT' [mx_uint] id #}++{# typedef uint64_t Word64#}+{# default in `Word64' [uint64_t] id #}++{#+pointer DataIterCreator newtype+#}++deriving instance Storable DataIterCreator++{#+pointer DataIterHandle foreign newtype +#}++deriving instance Generic DataIterHandle++type DataIterHandlePtr = Ptr DataIterHandle++newDataIterHandle :: DataIterHandlePtr -> IO DataIterHandle+newDataIterHandle ptr = newForeignPtr ptr (mxDataIterFree ptr) >>= return . DataIterHandle++peekDataIterHandle :: Ptr DataIterHandlePtr -> IO DataIterHandle+peekDataIterHandle = peek >=> newDataIterHandle++finalizeDataIterHandle :: DataIterHandle -> IO ()+finalizeDataIterHandle (DataIterHandle fptr) = finalizeForeignPtr fptr++{#+fun MXDataIterFree as mxDataIterFree_+    {+        id `DataIterHandlePtr'+    } -> `CInt'+#}++mxDataIterFree :: DataIterHandlePtr -> IO ()+mxDataIterFree = checked . mxDataIterFree_+++{#+fun MXListDataIters as mxListDataIters_+    { +        alloca- `MX_UINT' peek*, +        alloca- `Ptr DataIterCreator' peek*+    } -> `CInt' +#}++mxListDataIters :: IO [DataIterCreator]+mxListDataIters = do+    (cnt, ptr) <- checked mxListDataIters_+    peekArray (fromIntegral cnt :: Int) ptr++{#+fun MXDataIterGetIterInfo as mxDataIterGetIterInfo_+    { +        `DataIterCreator', +        alloca- `String' peekString*,+        alloca- `String' peekString*,+        alloca- `MX_UINT' peek*,+        alloca- `Ptr (Ptr CChar)' peek*,+        alloca- `Ptr (Ptr CChar)' peek*,+        alloca- `Ptr (Ptr CChar)' peek*+    } -> `CInt'+#}++mxDataIterGetIterInfo :: DataIterCreator -> IO (String, String, [String], [String], [String])+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+    return (name, descr, arg_names_, arg_type_infos_, arg_descs_)++{#+fun MXDataIterCreateIter as mxDataIterCreateIter_+    { +        `DataIterCreator', +        `MX_UINT',+        withStringArray* `[String]',+        withStringArray* `[String]',+        alloca- `DataIterHandle' peekDataIterHandle*+    } -> `CInt'+#}++mxDataIterCreateIter :: DataIterCreator -> [String] -> [String] -> 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', +        alloca- `CInt' peek*+    } -> `CInt'+#}++mxDataIterNext :: DataIterHandle -> IO Int+mxDataIterNext dataiter = do+    next <- checked $ mxDataIterNext_ dataiter+    return $ fromIntegral next++{#+fun MXDataIterBeforeFirst as mxDataIterBeforeFirst_+    { +        `DataIterHandle'+    } -> `CInt'+#}++mxDataIterBeforeFirst :: DataIterHandle -> IO ()+mxDataIterBeforeFirst = checked . mxDataIterBeforeFirst_++{#+fun MXDataIterGetData as mxDataIterGetData_+    { +        `DataIterHandle',+        alloca- `NDArrayHandle' peekNDArrayHandle*+    } -> `CInt'+#}++mxDataIterGetData :: DataIterHandle -> IO NDArrayHandle+mxDataIterGetData = checked . mxDataIterGetData_++{#+fun MXDataIterGetIndex as mxDataIterGetIndex_+    { +        `DataIterHandle',+        alloca- `Ptr Word64' peek*,+        alloca- `Word64' peek*+    } -> `CInt'+#}++mxDataIterGetIndex :: DataIterHandle -> IO [Integer]+mxDataIterGetIndex dataiter = do+    (ptr, cnt) <- checked $ mxDataIterGetIndex_ dataiter+    peekIntegralArray (fromIntegral cnt) ptr++{#+fun MXDataIterGetPadNum as mxDataIterGetPadNum_+    { +        `DataIterHandle',+        alloca- `CInt' peek*+    } -> `CInt'+#}++mxDataIterGetPadNum :: DataIterHandle -> IO Int+mxDataIterGetPadNum dataiter = do+    next <- checked $ mxDataIterGetPadNum_ dataiter+    return $ fromIntegral next++{#+fun MXDataIterGetLabel as mxDataIterGetLabel_+    { +        `DataIterHandle',+        alloca- `NDArrayHandle' peekNDArrayHandle*+    } -> `CInt'+#}++mxDataIterGetLabel :: DataIterHandle -> IO NDArrayHandle+mxDataIterGetLabel = checked . mxDataIterGetLabel_+
+ c-apis/MXNet/Base/Raw/Executor.chs view
@@ -0,0 +1,414 @@+{-# LANGUAGE ScopedTypeVariables #-}+module MXNet.Base.Raw.Executor where++import Foreign.Marshal (alloca, withArray, peekArray)+import Foreign.Storable (Storable(..))+import Foreign.Concurrent (newForeignPtr)+import Foreign.ForeignPtr (newForeignPtr_, touchForeignPtr)+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 MXNet.Base.Raw.Common #}+{# import MXNet.Base.Raw.NDArray #}+{# import MXNet.Base.Raw.Symbol #}++#include <mxnet/c_api.h>++{# typedef size_t CSize#}+{# default in `CSize' [size_t] fromIntegral #}+{# typedef mx_uint MX_UINT#}+{# default in `MX_UINT' [mx_uint] id #}++{#+pointer ExecutorHandle foreign newtype +#}++deriving instance Generic ExecutorHandle++type ExecutorHandlePtr = Ptr ExecutorHandle++touchExecutorHandle :: ExecutorHandle -> IO ()+touchExecutorHandle (ExecutorHandle fptr) = touchForeignPtr fptr++newExecutorHandle :: ExecutorHandlePtr -> IO ExecutorHandle+newExecutorHandle ptr = newForeignPtr ptr (mxExecutorFree ptr) >>= return . ExecutorHandle++peekExecutorHandle :: Ptr ExecutorHandlePtr -> IO ExecutorHandle+peekExecutorHandle = peek >=> newExecutorHandle++withExecutorHandleArray :: [ExecutorHandle] -> (Ptr ExecutorHandlePtr -> IO r) -> IO r+withExecutorHandleArray array io = do+    let unExecutorHandle (ExecutorHandle fptr) = fptr+    r <- withArray (map (unsafeForeignPtrToPtr . unExecutorHandle) array) io+    mapM_ (touchForeignPtr . unExecutorHandle) array+    return r++{#+fun MXExecutorFree as mxExecutorFree_+    {+        id `ExecutorHandlePtr'+    } -> `CInt'+#}++mxExecutorFree :: ExecutorHandlePtr -> IO ()+mxExecutorFree = checked . mxExecutorFree_++{#+fun MXExecutorPrint as mxExecutorPrint_+    {+        `ExecutorHandle',+        alloca- `String' peekString*+    } -> `CInt'+#}++mxExecutorPrint :: ExecutorHandle -> IO String+mxExecutorPrint = checked . mxExecutorPrint_++{#+fun MXExecutorForward as mxExecutorForward_+    {+        `ExecutorHandle',+        `CInt'+    } -> `CInt'+#}++mxExecutorForward :: ExecutorHandle -> Bool -> IO ()+mxExecutorForward exec train = checked $ mxExecutorForward_ exec is_train+  where+    is_train = if train then 1 else 0++{#+fun MXExecutorBackward as mxExecutorBackward_+    {+        `ExecutorHandle',+        `MX_UINT',+        withNDArrayHandleArray* `[NDArrayHandle]'+    } -> `CInt'+#}++mxExecutorBackward :: ExecutorHandle -> [NDArrayHandle] -> IO ()+mxExecutorBackward exec head_grads = checked $ mxExecutorBackward_ exec cnt head_grads+  where+    cnt = fromIntegral $ length head_grads++{#+fun MXExecutorBackwardEx as mxExecutorBackwardEx_+    {+        `ExecutorHandle',+        `MX_UINT',+        withNDArrayHandleArray* `[NDArrayHandle]',+        `CInt'+    } -> `CInt'+#}++mxExecutorBackwardEx :: ExecutorHandle -> [NDArrayHandle] -> Bool -> IO ()+mxExecutorBackwardEx exec head_grads train = checked $ mxExecutorBackwardEx_ exec cnt head_grads is_train+  where+    cnt = fromIntegral $ length head_grads+    is_train = if train then 1 else 0++{#+fun MXExecutorOutputs as mxExecutorOutputs_+    {+        `ExecutorHandle',+        alloca- `MX_UINT' peek*,+        alloca- `Ptr NDArrayHandlePtr' peek*+    } -> `CInt'+#}++mxExecutorOutputs :: ExecutorHandle -> IO [NDArrayHandle]+mxExecutorOutputs handle = do+    (cnt, ptr) <- checked $ mxExecutorOutputs_ handle+    handle_ptrs <- peekArray (fromIntegral cnt) ptr+    mapM newNDArrayHandle handle_ptrs++{#+fun MXExecutorBind as mxExecutorBind_+    {+        `SymbolHandle',+        `CInt',+        `CInt',+        `MX_UINT',+        withNDArrayHandleArray* `[NDArrayHandle]',+        withNDArrayHandleArray* `[NDArrayHandle]',+        withArray* `[MX_UINT]',+        `MX_UINT',+        withNDArrayHandleArray* `[NDArrayHandle]',+        alloca- `ExecutorHandle' peekExecutorHandle*+    } -> `CInt'+#}++makeNullNDArrayHandle = NDArrayHandle <$> newForeignPtr_ C2HSImp.nullPtr++mxExecutorBind :: SymbolHandle+               -> Int +               -> Int+               -> [NDArrayHandle]+               -> [Maybe NDArrayHandle]+               -> [Int]+               -> [NDArrayHandle]+               -> IO ExecutorHandle+mxExecutorBind symbol devtype devid in_args arg_grad_store grad_req_type aux_states = do+    nullNDArrayHandle <- makeNullNDArrayHandle+    let arg_grad_store_ = map (fromMaybe nullNDArrayHandle) arg_grad_store+    checked $ mxExecutorBind_ symbol devtype_ devid_ cnt_args in_args arg_grad_store_ grad_req_type_ cnt_auxs aux_states+  where+    devtype_ = fromIntegral devtype+    devid_   = fromIntegral devid+    cnt_args = fromIntegral $ length arg_grad_store+    cnt_auxs = fromIntegral $ length aux_states+    grad_req_type_ = map fromIntegral grad_req_type++{#+fun MXExecutorBindX as mxExecutorBindX_+    {+        `SymbolHandle',+        `CInt',+        `CInt',+        `MX_UINT',+        withStringArray* `[String]',+        withArray* `[CInt]',+        withArray* `[CInt]',+        `MX_UINT',+        withNDArrayHandleArray* `[NDArrayHandle]',+        withNDArrayHandleArray* `[NDArrayHandle]',+        withArray* `[MX_UINT]',+        `MX_UINT',+        withNDArrayHandleArray* `[NDArrayHandle]',+        alloca- `ExecutorHandle' peekExecutorHandle*+    } -> `CInt'+#}++mxExecutorBindX :: SymbolHandle+                -> Int +                -> Int+                -> [String]+                -> [Int]+                -> [Int]+                -> [NDArrayHandle]+                -> [Maybe NDArrayHandle]+                -> [Int]+                -> [NDArrayHandle]+                -> IO ExecutorHandle+mxExecutorBindX symbol devtype devid map_keys map_dev_types map_dev_ids in_args arg_grad_store grad_req_type aux_states = do+    nullNDArrayHandle <- makeNullNDArrayHandle+    let arg_grad_store_ = map (fromMaybe nullNDArrayHandle) arg_grad_store+    checked $ mxExecutorBindX_ symbol devtype_ devid_ cnt_maps map_keys map_dev_types_ map_dev_ids_ cnt_args in_args arg_grad_store_ grad_req_type_ cnt_auxs aux_states+  where+    devtype_ = fromIntegral devtype+    devid_   = fromIntegral devid+    cnt_maps = fromIntegral $ length map_keys+    map_dev_types_ = map fromIntegral map_dev_types+    map_dev_ids_ = map fromIntegral map_dev_ids+    cnt_args = fromIntegral $ length arg_grad_store+    cnt_auxs = fromIntegral $ length aux_states+    grad_req_type_ = map fromIntegral grad_req_type++{#+fun MXExecutorBindEX as mxExecutorBindEX_+    {+        `SymbolHandle',+        `CInt',+        `CInt',+        `MX_UINT',+        withStringArray* `[String]',+        withArray* `[CInt]',+        withArray* `[CInt]',+        `MX_UINT',+        withNDArrayHandleArray* `[NDArrayHandle]',+        withNDArrayHandleArray* `[NDArrayHandle]',+        withArray* `[MX_UINT]',+        `MX_UINT',+        withNDArrayHandleArray* `[NDArrayHandle]',+        `ExecutorHandle',+        alloca- `ExecutorHandle' peekExecutorHandle*+    } -> `CInt'+#}++mxExecutorBindEX :: SymbolHandle+                 -> Int +                 -> Int+                 -> [String]+                 -> [Int]+                 -> [Int]+                 -> [NDArrayHandle]+                 -> [Maybe NDArrayHandle]+                 -> [Int]+                 -> [NDArrayHandle]+                 -> ExecutorHandle+                 -> IO ExecutorHandle+mxExecutorBindEX symbol devtype devid map_keys map_dev_types map_dev_ids in_args arg_grad_store grad_req_type aux_states shared_exec = do+    nullNDArrayHandle <- makeNullNDArrayHandle+    let arg_grad_store_ = map (fromMaybe nullNDArrayHandle) arg_grad_store+    checked $ mxExecutorBindEX_ symbol devtype_ devid_ cnt_maps map_keys map_dev_types_ map_dev_ids_ cnt_args in_args arg_grad_store_ grad_req_type_ cnt_auxs aux_states shared_exec+  where+    devtype_ = fromIntegral devtype+    devid_   = fromIntegral devid+    cnt_maps = fromIntegral $ length map_keys+    map_dev_types_ = map fromIntegral map_dev_types+    map_dev_ids_ = map fromIntegral map_dev_ids+    cnt_args = fromIntegral $ length arg_grad_store+    cnt_auxs = fromIntegral $ length aux_states+    grad_req_type_ = map fromIntegral grad_req_type++{#+fun MXExecutorSimpleBind as mxExecutorSimpleBind_+    {+        `SymbolHandle',+        `CInt',+        `CInt',+        `MX_UINT',+        withStringArray* `[String]',+        withArray* `[CInt]',+        withArray* `[CInt]',+        `MX_UINT',+        withStringArray* `[String]',+        withStringArray* `[String]',+        `MX_UINT',+        withStringArray* `[String]',+        withArray* `[MX_UINT]',+        withArray* `[MX_UINT]',+        `MX_UINT',+        withStringArray* `[String]',+        withArray* `[CInt]',+        `MX_UINT',+        withStringArray* `[String]',+        withArray* `[CInt]',+        `MX_UINT',+        withStringArray* `[String]',+        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- `MX_UINT' peek*,+        alloca- `Ptr NDArrayHandlePtr' peek*,+        alloca- `Ptr NDArrayHandlePtr' peek*,+        alloca- `MX_UINT' peek*,+        alloca- `Ptr NDArrayHandlePtr' peek*,+        `ExecutorHandle',+        alloca- `ExecutorHandle' peekExecutorHandle*        +    } -> `CInt'+#}++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+                     -> ExecutorHandle                    -- shared_exec_handle+                     -> IO (Maybe ([String], [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 +                     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 +                     shared_exec_handle =+    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 +                        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_+                        cnt_shared_arg_names shared_arg_name_list+                        ptr_shared_buffer_len C2HSImp.nullPtr C2HSImp.nullPtr+                        shared_exec_handle+            arg_array  <- peekArray (fromIntegral num_in_args) in_args   >>= mapM newNDArrayHandle+            grad_array <- peekArray (fromIntegral num_in_args) arg_grads >>= mapM newNDArrayHandle+            aux_array  <- peekArray (fromIntegral num_aux_states) aux_states >>= mapM newNDArrayHandle+            return (Nothing, arg_array, grad_array, aux_array, out))++        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 -> +                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 +                                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_+                                cnt_shared_arg_names shared_arg_name_list+                                ptr_shared_buffer_len ptr_shared_buffer_name_list ptr_shared_buffer_handle_list+                                shared_exec_handle+                    arg_array  <- peekArray (fromIntegral num_in_args) in_args   >>= mapM newNDArrayHandle+                    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_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)+                )))++  where+    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_grad_req_list = fromIntegral $ length provided_grad_req_names+    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+    cnt_provided_arg_dtypes = fromIntegral $ length provided_arg_dtype_names+    provided_arg_dtypes_ = map fromIntegral provided_arg_dtypes+    cnt_provided_arg_stypes = fromIntegral $ length provided_arg_stype_names+    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'+-- #}++-- {# +-- fun MXExecutorGetOptimizedSymbol as mxExecutorGetOptimizedSymbol_+--     {+--         `ExecutorHandle',+--         alloca- `SymbolHandle' peekSymbolHandle*+--     } -> `CInt'+-- #}
+ c-apis/MXNet/Base/Raw/NDArray.chs view
@@ -0,0 +1,353 @@+{-# LANGUAGE ScopedTypeVariables #-}+module MXNet.Base.Raw.NDArray where++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.Ptr+import C2HS.C.Extra.Marshal (withIntegralArray, peekStringArray)+import GHC.Generics (Generic)+import Control.Monad ((>=>))++{# import MXNet.Base.Raw.Common #}++#include <mxnet/c_api.h>++{# typedef size_t CSize#}+{# default in `CSize' [size_t] fromIntegral #}+{# typedef mx_uint MX_UINT#}+{# default in `MX_UINT' [mx_uint] id #}++-- NDArray+{#+pointer NDArrayHandle foreign newtype +#}++deriving instance Generic NDArrayHandle+deriving instance Show NDArrayHandle+type NDArrayHandlePtr = Ptr NDArrayHandle++touchNDArrayHandle :: NDArrayHandle -> IO ()+touchNDArrayHandle (NDArrayHandle fptr) = touchForeignPtr fptr++newNDArrayHandle :: NDArrayHandlePtr -> IO NDArrayHandle+newNDArrayHandle ptr = do+    hdl <- newForeignPtr ptr (mxNDArrayFree ptr)+    return $ NDArrayHandle hdl++peekNDArrayHandle :: Ptr NDArrayHandlePtr -> IO NDArrayHandle+peekNDArrayHandle = peek >=> newNDArrayHandle++withNDArrayHandleArray :: [NDArrayHandle] -> (Ptr NDArrayHandlePtr -> IO r) -> IO r+withNDArrayHandleArray array io = do+    let unNDArrayHandle (NDArrayHandle fptr) = fptr+    r <- withArray (map (unsafeForeignPtrToPtr . unNDArrayHandle) array) io+    mapM_ (touchForeignPtr . unNDArrayHandle) array+    return r++{#+fun MXNDArrayFree as mxNDArrayFree_+    {+        id `NDArrayHandlePtr'+    } -> `CInt'+#}++mxNDArrayFree :: NDArrayHandlePtr -> IO ()+mxNDArrayFree = checked . mxNDArrayFree_++{#+fun MXNDArrayCreateNone as mxNDArrayCreateNone_+    {+        alloca- `NDArrayHandle' peekNDArrayHandle*+    } -> `CInt'+#}++mxNDArrayCreateNone :: IO NDArrayHandle+mxNDArrayCreateNone = checked mxNDArrayCreateNone_++{#+fun MXNDArrayCreate as mxNDArrayCreate_+    {+        withArray* `[MX_UINT]',+        id `MX_UINT',+        `CInt',+        `CInt',+        `CInt',+        alloca- `NDArrayHandle' peekNDArrayHandle*+    } -> `CInt'+#}++mxNDArrayCreate :: [Int] -> Int -> Int -> Bool -> IO NDArrayHandle+mxNDArrayCreate shape devtype devid delay_alloc = do+    let shape_   = fromIntegral <$> shape+        dim_     = fromIntegral (length shape_)+        devtype_ = fromIntegral devtype+        devid_   = fromIntegral devid+    checked $ mxNDArrayCreate_ shape_ dim_ devtype_ devid_ (if delay_alloc then 1 else 0)++{#+fun MXNDArrayCreateEx as mxNDArrayCreateEx_+    {+        withArray* `[MX_UINT]',+        id `MX_UINT',+        `CInt',+        `CInt',+        `CInt',+        `CInt',+        alloca- `NDArrayHandle' peekNDArrayHandle*+    } -> `CInt'+#}++mxNDArrayCreateEx :: [Int] -> Int -> Int -> Bool -> Int -> IO NDArrayHandle+mxNDArrayCreateEx shape devtype devid delay_alloc dtype = do+    let shape_   = fromIntegral <$> shape+        dim_     = fromIntegral (length shape_)+        devtype_ = fromIntegral devtype+        devid_   = fromIntegral devid+        dtype_   = fromIntegral dtype+    checked $ mxNDArrayCreateEx_ shape_ dim_ devtype_ devid_ (if delay_alloc then 1 else 0) dtype_+++{#+fun MXNDArraySyncCopyFromCPU as mxNDArraySyncCopyFromCPU_+    {+        `NDArrayHandle',+        id `Ptr ()',+        `CSize'+    } -> `CInt'+#}++mxNDArraySyncCopyFromCPU :: NDArrayHandle -> Ptr () -> Int -> IO ()+mxNDArraySyncCopyFromCPU array ptr size =+    checked $ mxNDArraySyncCopyFromCPU_ array ptr (fromIntegral size)++{#+fun MXNDArraySyncCopyToCPU as mxNDArraySyncCopyToCPU_+    {+        `NDArrayHandle',+        id `Ptr ()',+        `CSize'+    } -> `CInt'+#}++mxNDArraySyncCopyToCPU :: NDArrayHandle -> Ptr () -> Int -> IO ()+mxNDArraySyncCopyToCPU array ptr size =+    checked $ mxNDArraySyncCopyToCPU_ array ptr (fromIntegral size)++{#+fun MXNDArraySyncCopyFromNDArray as mxNDArraySyncCopyFromNDArray_+    {+        `NDArrayHandle',+        `NDArrayHandle',+        `CInt'+    } -> `CInt'+#}++mxNDArraySyncCopyFromNDArray :: NDArrayHandle -> NDArrayHandle -> Int -> IO ()+mxNDArraySyncCopyFromNDArray array_dst array_src blob =+    checked $ mxNDArraySyncCopyFromNDArray_ array_dst array_src (fromIntegral blob)++{#+fun MXNDArrayWaitToRead as mxNDArrayWaitToRead_+    {+        `NDArrayHandle'+    } -> `CInt'+#}++mxNDArrayWaitToRead :: NDArrayHandle -> IO ()+mxNDArrayWaitToRead = checked . mxNDArrayWaitToRead_++{#+fun MXNDArrayWaitToWrite as mxNDArrayWaitToWrite_+    {+        `NDArrayHandle'+    } -> `CInt'+#}++mxNDArrayWaitToWrite :: NDArrayHandle -> IO ()+mxNDArrayWaitToWrite = checked . mxNDArrayWaitToWrite_++{#+fun MXNDArrayWaitAll as mxNDArrayWaitAll_+    {+    } -> `CInt'+#}++mxNDArrayWaitAll :: IO ()+mxNDArrayWaitAll = checked mxNDArrayWaitAll_++{#+fun MXNDArraySlice as mxNDArraySlice_+    {+        `NDArrayHandle',+        `MX_UINT',+        `MX_UINT',+        alloca- `NDArrayHandle' peekNDArrayHandle*+    } -> `CInt'+#}++mxNDArraySlice :: NDArrayHandle -> Int -> Int -> IO NDArrayHandle+mxNDArraySlice array begin end = do+    let begin_ = fromIntegral begin+        end_   = fromIntegral end+    checked $ mxNDArraySlice_ array begin_ end_++{#+fun MXNDArrayAt as mxNDArrayAt_+    {+        `NDArrayHandle',+        `MX_UINT',+        alloca- `NDArrayHandle' peekNDArrayHandle*+    } -> `CInt'+#}++mxNDArrayAt :: NDArrayHandle -> Int -> IO NDArrayHandle+mxNDArrayAt array index = do+    checked $ mxNDArrayAt_ array (fromIntegral index)++{#+fun MXNDArrayGetStorageType as mxNDArrayGetStorageType_+    {+        `NDArrayHandle',+        alloca- `CInt' peek*+    } -> `CInt'+#}++mxNDArrayGetStorageType :: NDArrayHandle -> IO Int+mxNDArrayGetStorageType array = do+    storageType <- checked $ mxNDArrayGetStorageType_ array+    return $ fromIntegral storageType++{#+fun MXNDArrayReshape as mxNDArrayReshape_+    {+        `NDArrayHandle',+        `CInt',+        withIntegralArray* `[CInt]',+        alloca- `NDArrayHandle' peekNDArrayHandle*+    } -> `CInt'+#}++mxNDArrayReshape :: NDArrayHandle -> [Int] -> IO NDArrayHandle+mxNDArrayReshape array shape = do+    let shape_ = fromIntegral <$> shape+        num_   = fromIntegral $ length shape_+    checked $ mxNDArrayReshape_ array num_ shape_++{#+fun MXNDArrayGetShape as mxNDArrayGetShape_+    {+        `NDArrayHandle',+        alloca- `MX_UINT' peek*,+        alloca- `Ptr MX_UINT' peek*+    } -> `CInt'+#}++mxNDArrayGetShape :: NDArrayHandle -> IO [Int]+mxNDArrayGetShape array = do+    (size, ptr) <- checked $ mxNDArrayGetShape_ array+    shape <- peekArray (fromIntegral size) ptr+    return $ fromIntegral <$> shape++-- MXImperativeInvoke is hacky.+-- 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+{#+fun MXImperativeInvoke as mxImperativeInvoke_+    {+        `AtomicSymbolCreator',+        `CInt',+        withNDArrayHandleArray* `[NDArrayHandle]',+        id `Ptr CInt',                    -- num-outputs+        id `Ptr (Ptr NDArrayHandlePtr)',  -- array-of-NDArrayHandle+        `CInt',+        withStringArray* `[String]',+        withStringArray* `[String]'+    } -> `CInt'+#}++-- | Invoke a nnvm op and imperative function.+mxImperativeInvoke :: AtomicSymbolCreator+                   -> [NDArrayHandle]+                   -> [(String, String)]+                   -> Maybe [NDArrayHandle]+                   -> IO [NDArrayHandle]+mxImperativeInvoke creator inputs params outputs = do+    let (keys, values) = unzip params+        ninput = fromIntegral $ length inputs+        nparam = fromIntegral $ length params+    case outputs of+        Nothing -> alloca $ \(pn :: Ptr CInt) ->+            alloca $ \(pp :: Ptr (Ptr NDArrayHandlePtr)) -> do+                poke pn 0+                poke pp C2HSImp.nullPtr+                checked $ mxImperativeInvoke_ creator ninput inputs pn pp nparam keys values+                n' <- peek pn+                p' <- peek pp+                if n' == 0 +                    then return []+                    else do+                        pa <- peekArray (fromIntegral n') (p' :: Ptr NDArrayHandlePtr)+                        mapM newNDArrayHandle pa+        Just out -> alloca $ \(pn :: Ptr CInt) ->+            alloca $ \(pp :: Ptr (Ptr NDArrayHandlePtr)) -> do+                n' <- withNDArrayHandleArray out $ \p' -> do+                    poke pn (fromIntegral $ length out)+                    poke pp p'+                    checked $ mxImperativeInvoke_ creator ninput inputs pn pp nparam keys values+                    peek pn+                return $ take (fromIntegral n') out++{#+fun MXNDArrayGetContext as mxNDArrayGetContext_+    {+        `NDArrayHandle',+        alloca- `CInt' peek*,+        alloca- `CInt' peek*+    } -> `CInt'+#}++mxNDArrayGetContext :: NDArrayHandle -> IO (Int, Int)+mxNDArrayGetContext handle = do+    (devtyp, devidx) <- checked $ mxNDArrayGetContext_ handle+    return (fromIntegral devtyp, fromIntegral devidx)+++{#+fun MXNDArraySave as mxNDArraySave_ +    {+        `String',+        `MX_UINT',+        withNDArrayHandleArray* `[NDArrayHandle]',+        withStringArray* `[String]'+    } -> `CInt'+#}++mxNDArraySave ::  String -> [(String, NDArrayHandle)] -> IO ()+mxNDArraySave filename keyvals = do+    let num = length keyvals+        (keys, vals) = unzip keyvals+    checked $ mxNDArraySave_ filename (fromIntegral num) vals keys++{#+fun MXNDArrayLoad as mxNDArrayLoad_+    {+        `String',+        alloca- `MX_UINT' peek*,+        alloca- `Ptr NDArrayHandlePtr' peek*,+        alloca- `MX_UINT' peek*,+        alloca- `Ptr (Ptr CChar)' peek*+    } -> `CInt'+#}++mxNDArrayLoad :: String -> IO [(String, NDArrayHandle)]+mxNDArrayLoad path = do+    (numArrays, ptrArrays, numNames, ptrNames) <- checked $ mxNDArrayLoad_ path+    pa <- peekArray (fromIntegral numArrays) ptrArrays+    arrays <- mapM newNDArrayHandle pa+    names <- peekStringArray numNames ptrNames+    return $ zip names arrays
+ c-apis/MXNet/Base/Raw/Symbol.chs view
@@ -0,0 +1,561 @@+{-# LANGUAGE ScopedTypeVariables #-}+module MXNet.Base.Raw.Symbol where++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.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 #}++#include <mxnet/c_api.h>++{# typedef size_t CSize#}+{# default in `CSize' [size_t] fromIntegral #}+{# typedef mx_uint MX_UINT#}+{# default in `MX_UINT' [mx_uint] id #}++{#+pointer SymbolHandle foreign newtype+#}++deriving instance Generic SymbolHandle+deriving instance Show SymbolHandle+type SymbolHandlePtr = Ptr SymbolHandle++touchSymbolHandle :: SymbolHandle -> IO ()+touchSymbolHandle (SymbolHandle fptr) = touchForeignPtr fptr++newSymbolHandle :: SymbolHandlePtr -> IO SymbolHandle+newSymbolHandle ptr = newForeignPtr ptr (mxSymbolFree ptr) >>= return . SymbolHandle++peekSymbolHandle :: Ptr SymbolHandlePtr -> IO SymbolHandle+peekSymbolHandle = peek >=> newSymbolHandle++withSymbolHandleArray :: [SymbolHandle] -> (Ptr SymbolHandlePtr -> IO r) -> IO r+withSymbolHandleArray array io = do+    let unSymbolHandle (SymbolHandle fptr) = fptr+    r <- withArray (map (unsafeForeignPtrToPtr . unSymbolHandle) array) io+    mapM_ (touchForeignPtr . unSymbolHandle) array+    return r++{#+fun MXSymbolFree as mxSymbolFree_+    {+        id `SymbolHandlePtr'+    } -> `CInt'+#}++mxSymbolFree :: SymbolHandlePtr -> IO ()+mxSymbolFree = checked . mxSymbolFree_++{#+fun MXSymbolCreateAtomicSymbol as mxSymbolCreateAtomicSymbol_+    {+        `AtomicSymbolCreator',+        `MX_UINT',+        withStringArray* `[String]',+        withStringArray* `[String]',+        alloca- `SymbolHandle' peekSymbolHandle*+    } -> `CInt'+#}++mxSymbolCreateAtomicSymbol :: AtomicSymbolCreator+                           -> [String]+                           -> [String]+                           -> IO SymbolHandle+mxSymbolCreateAtomicSymbol creator keys vals = do+    let argcnt = fromIntegral $ length keys+    checked $ mxSymbolCreateAtomicSymbol_ creator argcnt keys vals++{#+fun MXSymbolCreateVariable as mxSymbolCreateVariable_+    {+        `String',+        alloca- `SymbolHandle' peekSymbolHandle*+    } -> `CInt'+#}++mxSymbolCreateVariable :: String -> IO SymbolHandle+mxSymbolCreateVariable = checked . mxSymbolCreateVariable_++{#+fun MXSymbolCreateGroup as mxSymbolCreateGroup_+    {+        `MX_UINT',+        withSymbolHandleArray* `[SymbolHandle]',+        alloca- `SymbolHandle' peekSymbolHandle*+    } -> `CInt'+#}++mxSymbolCreateGroup :: [SymbolHandle] -> IO SymbolHandle+mxSymbolCreateGroup syms = checked $ mxSymbolCreateGroup_ (fromIntegral $ length syms) syms++{#+fun MXSymbolCreateFromJSON as mxSymbolCreateFromJSON_+    {+        `String',+        alloca- `SymbolHandle' peekSymbolHandle*+    } -> `CInt'+#}++mxSymbolCreateFromJSON :: String -> IO SymbolHandle+mxSymbolCreateFromJSON = checked . mxSymbolCreateFromJSON_++{#+fun MXSymbolSaveToJSON as mxSymbolSaveToJSON_+    {+        `SymbolHandle',+        alloca- `String' peekString*+    } -> `CInt'+#}++mxSymbolSaveToJSON :: SymbolHandle -> IO String+mxSymbolSaveToJSON = checked . mxSymbolSaveToJSON_++{#+fun MXSymbolCopy as mxSymbolCopy_+    {+        `SymbolHandle',+        alloca- `SymbolHandle' peekSymbolHandle*+    } -> `CInt'+#}++mxSymbolCopy :: SymbolHandle -> IO SymbolHandle+mxSymbolCopy = checked . mxSymbolCopy_++{#+fun MXSymbolPrint as mxSymbolPrint_+    {+        `SymbolHandle',+        alloca- `String' peekString*+    } -> `CInt'+#}++mxSymbolPrint :: SymbolHandle -> IO String+mxSymbolPrint = checked . mxSymbolPrint_++{#+fun MXSymbolGetName as mxSymbolGetName_+    {+        `SymbolHandle',+        alloca- `Ptr (Ptr CChar)' id,+        alloca- `CInt' peek*+    } -> `CInt'+#}++mxSymbolGetName :: SymbolHandle -> IO (Maybe String)+mxSymbolGetName symbol = do+    (out, succ) <- checked $ mxSymbolGetName_ symbol+    if succ == 0 then+        Just <$> peekString out+    else+        return Nothing++{#+fun MXSymbolGetAttr as mxSymbolGetAttr_+    {+        `SymbolHandle',+        `String',+        alloca- `Ptr (Ptr CChar)' id,+        alloca- `CInt' peek*+    } -> `CInt'+#}++mxSymbolGetAttr :: SymbolHandle+                -> String+                -> IO (Maybe String)+mxSymbolGetAttr symbol key = do+    (pstr, succ) <- checked $ mxSymbolGetAttr_ symbol key+    if succ == 0 then+        Just <$> peekString pstr+    else+        return Nothing++{#+fun MXSymbolSetAttr as mxSymbolSetAttr_+    {+        `SymbolHandle',+        `String',+        `String'+    } -> `CInt'+#}++mxSymbolSetAttr :: SymbolHandle+                -> String+                -> String+                -> IO ()+mxSymbolSetAttr symbol key val = checked $ mxSymbolSetAttr_ symbol key val++{#+fun MXSymbolListAttr as mxSymbolListAttr_+    {+        `SymbolHandle',+        alloca- `MX_UINT' peek*,+        alloca- `Ptr (Ptr CChar)' peek*+    } -> `CInt'+#}++mxSymbolListAttr :: SymbolHandle+                 -> IO [String]+mxSymbolListAttr symbol = do+    (cnt, ptr) <- checked $ mxSymbolListAttr_ symbol+    peekStringArray (fromIntegral cnt) ptr++{#+fun MXSymbolListAttrShallow as mxSymbolListAttrShallow_+    {+        `SymbolHandle',+        alloca- `MX_UINT' peek*,+        alloca- `Ptr (Ptr CChar)' peek*+    } -> `CInt'+#}++mxSymbolListAttrShallow :: SymbolHandle+                        -> IO [String]+mxSymbolListAttrShallow symbol = do+    (cnt, ptr) <- checked $ mxSymbolListAttrShallow_ symbol+    peekStringArray (fromIntegral cnt) ptr++{#+fun MXSymbolListArguments as mxSymbolListArguments_+    {+        `SymbolHandle',+        alloca- `MX_UINT' peek*,+        alloca- `Ptr (Ptr CChar)' peek*+    } -> `CInt'+#}++mxSymbolListArguments :: SymbolHandle+                      -> IO [String]+mxSymbolListArguments symbol = do+    (cnt, ptr) <- checked $ mxSymbolListArguments_ symbol+    peekStringArray (fromIntegral cnt) ptr++{#+fun MXSymbolListOutputs as mxSymbolListOutputs_+    {+        `SymbolHandle',+        alloca- `MX_UINT' peek*,+        alloca- `Ptr (Ptr CChar)' peek*+    } -> `CInt'+#}++mxSymbolListOutputs :: SymbolHandle+                    -> IO [String]+mxSymbolListOutputs symbol = do+    (cnt, ptr) <- checked $ mxSymbolListOutputs_ symbol+    peekStringArray (fromIntegral cnt) ptr++{#+fun MXSymbolGetInternals as mxSymbolGetInternals_+    {+        `SymbolHandle',+        alloca- `SymbolHandle' peekSymbolHandle*+    } -> `CInt'+#}++mxSymbolGetInternals :: SymbolHandle -> IO SymbolHandle+mxSymbolGetInternals = checked . mxSymbolGetInternals_++{#+fun MXSymbolGetChildren as mxSymbolGetChildren_+    {+        `SymbolHandle',+        alloca- `SymbolHandle' peekSymbolHandle*+    } -> `CInt'+#}++mxSymbolGetChildren :: SymbolHandle -> IO SymbolHandle+mxSymbolGetChildren = checked . mxSymbolGetChildren_++{#+fun MXSymbolGetOutput as mxSymbolGetOutput_+    {+        `SymbolHandle',+        `MX_UINT',+        alloca- `SymbolHandle' peekSymbolHandle*+    } -> `CInt'+#}+mxSymbolGetOutput :: SymbolHandle+                   -> Int+                   -> IO SymbolHandle+mxSymbolGetOutput symbol ind =+    checked $ mxSymbolGetOutput_ symbol (fromIntegral ind)++{#+fun MXSymbolListAuxiliaryStates as mxSymbolListAuxiliaryStates_+    {+        `SymbolHandle',+        alloca- `MX_UINT' peek*,+        alloca- `Ptr (Ptr CChar)' peek*+    } -> `CInt'+#}+mxSymbolListAuxiliaryStates :: SymbolHandle -> IO [String]+mxSymbolListAuxiliaryStates symbol = do+    (cnt, ptr) <- checked $ mxSymbolListAuxiliaryStates_ symbol+    peekStringArray (fromIntegral cnt) ptr++{#+fun MXSymbolCompose as mxSymbolCompose_+    {+        `SymbolHandle',+        `String',+        `MX_UINT',+        id `Ptr (Ptr CChar)',+        withSymbolHandleArray* `[SymbolHandle]'+    } -> `CInt'+#}++mxSymbolCompose :: SymbolHandle+                -> String+                -> Maybe [String]+                -> [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++{#+fun MXSymbolInferShape as mxSymbolInferShape_+    {+        `SymbolHandle',+        `MX_UINT',+        withStringArray* `[String]',+        withArray* `[MX_UINT]',+        withArray* `[MX_UINT]',+        alloca- `MX_UINT' peek*,+        alloca- `Ptr MX_UINT' peek*,+        alloca- `Ptr (Ptr MX_UINT)' peek*,+        alloca- `MX_UINT' peek*,+        alloca- `Ptr MX_UINT' peek*,+        alloca- `Ptr (Ptr MX_UINT)' peek*,+        alloca- `MX_UINT' peek*,+        alloca- `Ptr MX_UINT' peek*,+        alloca- `Ptr (Ptr MX_UINT)' peek*,+        alloca- `CInt' peek*+    } -> `CInt'+#}++mxSymbolInferShape :: SymbolHandle+                   -> [String]+                   -> [Int]+                   -> [Int]+                   -> IO ([[Int]], [[Int]], [[Int]], Bool)+mxSymbolInferShape symbol keys arg_ind arg_shape = do+    let num_args' = fromIntegral (length keys)+        arg_ind'  = map fromIntegral arg_ind+        arg_shape'= map fromIntegral arg_shape+    (inshape_size , inshape_ndim , inshape_data ,+     outshape_size, outshape_ndim, outshape_data,+     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_data'    <- peekArray inshape_size' inshape_data+    inshape_data_ret <- mapM (uncurry peekArrayOfUInt) (zip inshape_ndim' inshape_data')+    let outshape_size'= fromIntegral outshape_size+    outshape_ndim'   <- peekArray outshape_size' outshape_ndim+    outshape_data'   <- peekArray outshape_size' outshape_data+    outshape_data_ret<- mapM (uncurry peekArrayOfUInt) (zip outshape_ndim' outshape_data')+    let auxshape_size'= fromIntegral auxshape_size+    auxshape_ndim'   <- peekArray auxshape_size' auxshape_ndim+    auxshape_data'   <- peekArray auxshape_size' auxshape_data+    auxshape_data_ret<- mapM (uncurry peekArrayOfUInt) (zip auxshape_ndim' auxshape_data')+    return (inshape_data_ret, outshape_data_ret, auxshape_data_ret, complete == 1)++{#+fun MXSymbolInferShapePartial as mxSymbolInferShapePartial_+    {+        `SymbolHandle',+        `MX_UINT',+        withStringArray* `[String]',+        withArray* `[MX_UINT]',+        withArray* `[MX_UINT]',+        alloca- `MX_UINT' peek*,+        alloca- `Ptr MX_UINT' peek*,+        alloca- `Ptr (Ptr MX_UINT)' peek*,+        alloca- `MX_UINT' peek*,+        alloca- `Ptr MX_UINT' peek*,+        alloca- `Ptr (Ptr MX_UINT)' peek*,+        alloca- `MX_UINT' peek*,+        alloca- `Ptr MX_UINT' peek*,+        alloca- `Ptr (Ptr MX_UINT)' peek*,+        alloca- `CInt' peek*+    } -> `CInt'+#}++mxSymbolInferShapePartial :: SymbolHandle+                   -> [String]+                   -> [Int]+                   -> [Int]+                   -> IO ([[Int]], [[Int]], [[Int]], Bool)+mxSymbolInferShapePartial symbol keys arg_ind arg_shape = do+    let num_args' = fromIntegral (length keys)+        arg_ind'  = map fromIntegral arg_ind+        arg_shape'= map fromIntegral arg_shape+    (inshape_size , inshape_ndim , inshape_data ,+     outshape_size, outshape_ndim, outshape_data,+     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_data'    <- peekArray inshape_size' inshape_data+    inshape_data_ret <- mapM (uncurry peekArrayOfUInt) (zip inshape_ndim' inshape_data')+    let outshape_size'= fromIntegral outshape_size+    outshape_ndim'   <- peekArray outshape_size' outshape_ndim+    outshape_data'   <- peekArray outshape_size' outshape_data+    outshape_data_ret<- mapM (uncurry peekArrayOfUInt) (zip outshape_ndim' outshape_data')+    let auxshape_size'= fromIntegral auxshape_size+    auxshape_ndim'   <- peekArray auxshape_size' auxshape_ndim+    auxshape_data'   <- peekArray auxshape_size' auxshape_data+    auxshape_data_ret<- mapM (uncurry peekArrayOfUInt) (zip auxshape_ndim' auxshape_data')+    return (inshape_data_ret, outshape_data_ret, auxshape_data_ret, complete == 1)++peekArrayOfUInt cnt ptr = peekIntegralArray (fromIntegral cnt)  ptr++{#+fun MXSymbolInferType as mxSymbolInferType_+    {+        `SymbolHandle',+        `MX_UINT',+        withStringArray* `[String]',+        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'+#}++mxSymbolInferType :: SymbolHandle+                  -> [String]+                  -> [Int]+                  -> IO (Maybe ([Int], [Int], [Int]))+mxSymbolInferType symbol keys arg_type = do+    let num_args = fromIntegral (length keys)+        arg_type'= map fromIntegral arg_type+    (inshape_size , inshape_data ,+     outshape_size, outshape_data,+     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+        return $ Just (inshape_data_ret, outshape_data_ret, auxshape_data_ret)+    else+        return Nothing++{#+fun MXSymbolSaveToFile as mxSymbolSaveToFile_+    {+        `SymbolHandle',+        `String'+    } -> `CInt'+#}++mxSymbolSaveToFile :: String -> SymbolHandle -> IO ()+mxSymbolSaveToFile filename sym = do+    checked $ mxSymbolSaveToFile_ sym filename++data MXCallbackList = MXCallbackList Int (Ptr (FunPtr (IO CInt))) (Ptr (Ptr ()))++instance Storable MXCallbackList where+    sizeOf _ = {#sizeof MXCallbackList#}+    alignment _ = {#alignof MXCallbackList#}+    peek ptr = do+        n <- {#get MXCallbackList.num_callbacks#} ptr+        callbacks <- {#get MXCallbackList.callbacks#} ptr+        contexts  <- {#get MXCallbackList.contexts#} ptr+        return (MXCallbackList (fromIntegral n) callbacks contexts)+    poke ptr (MXCallbackList n callbacks contexts) = do+        {#set MXCallbackList.num_callbacks#} ptr (fromIntegral n)+        {#set MXCallbackList.callbacks#} ptr callbacks+        {#set MXCallbackList.contexts#}  ptr contexts++type CustomOpPropCreator          = CString -> CInt -> Ptr CString -> Ptr CString -> Ptr () -> IO CInt+type CustomOpFBFunc               = CInt -> Ptr (Ptr ()) -> Ptr CInt -> Ptr CInt -> CInt -> Ptr () -> IO CInt+type CustomOpDelFunc              = Ptr () -> IO CInt+type CustomOpListFunc             = Ptr (Ptr CString) -> Ptr () -> IO CInt+type CustomOpInferShapeFunc       = CInt -> Ptr CInt -> Ptr (Ptr CInt) -> Ptr () -> IO CInt+type CustomOpInferStorageTypeFunc = CInt -> Ptr CInt -> Ptr () -> IO CInt+type CustomOpBackwardInferStorageTypeFunc = CInt -> Ptr CInt -> Ptr CInt -> Ptr () -> IO CInt+type CustomOpInferTypeFunc        = CInt -> Ptr CInt -> Ptr () -> IO CInt+type CustomOpBwdDepFunc           = Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Ptr CInt) -> Ptr () -> IO CInt+type CustomOpCreateFunc           = CString -> CInt -> Ptr (Ptr CUInt) -> Ptr CInt -> Ptr CInt -> Ptr MXCallbackList -> Ptr () -> IO CInt+type CustomFunctionBwdFunc        = CInt -> Ptr (Ptr NDArrayHandle) -> Ptr CInt -> Ptr CInt -> CInt -> Ptr () -> IO CInt+type CustomFunctionDelFunc        = Ptr () -> IO CInt++foreign import ccall "wrapper" mkCustomOpPropCreator    :: CustomOpPropCreator -> IO (FunPtr CustomOpPropCreator)+foreign import ccall "wrapper" mkCustomOpFBFunc         :: CustomOpFBFunc -> IO (FunPtr CustomOpFBFunc)+foreign import ccall "wrapper" mkCustomOpDelFunc        :: CustomOpDelFunc -> IO (FunPtr CustomOpDelFunc)+foreign import ccall "wrapper" mkCustomOpListFunc       :: CustomOpListFunc -> IO (FunPtr CustomOpListFunc)+foreign import ccall "wrapper" mkCustomOpInferShapeFunc :: CustomOpInferShapeFunc -> IO (FunPtr CustomOpInferShapeFunc)+foreign import ccall "wrapper" mkCustomOpInferStorageTypeFunc :: CustomOpInferStorageTypeFunc -> IO (FunPtr CustomOpInferStorageTypeFunc)+foreign import ccall "wrapper" mkCustomOpBackwardInferStorageTypeFunc :: CustomOpBackwardInferStorageTypeFunc -> IO (FunPtr CustomOpBackwardInferStorageTypeFunc)+foreign import ccall "wrapper" mkCustomOpInferTypeFunc  :: CustomOpInferTypeFunc -> IO (FunPtr CustomOpInferTypeFunc)+foreign import ccall "wrapper" mkCustomOpBwdDepFunc     :: CustomOpBwdDepFunc -> IO (FunPtr CustomOpBwdDepFunc)+foreign import ccall "wrapper" mkCustomOpCreateFunc     :: CustomOpCreateFunc -> IO (FunPtr CustomOpCreateFunc)+foreign import ccall "wrapper" mkCustomFunctionBwdFunc  :: CustomFunctionBwdFunc -> IO (FunPtr CustomFunctionBwdFunc)+foreign import ccall "wrapper" mkCustomFunctionDelFunc  :: CustomFunctionDelFunc -> IO (FunPtr CustomFunctionDelFunc)++{#+fun MXCustomOpRegister as mxCustomOpRegister_+    {+        `String',+        id `FunPtr CustomOpPropCreator'+    } -> `CInt'+#}++mxCustomOpRegister :: String -> FunPtr CustomOpPropCreator -> IO ()+mxCustomOpRegister op cr = checked $ mxCustomOpRegister_ op cr++-- {#+-- fun MXSymbolGetInputSymbols as mxSymbolGetInputSymbols_+--     {+--         `SymbolHandle',+--         alloca- `Ptr SymbolHandlePtr' peek*,+--         alloca- `CInt' peek*+--     } -> `CInt'+-- #}+--+{#+fun MXSymbolGetNumOutputs as mxSymbolGetNumOutputs_+    {+        `SymbolHandle',+        alloca- `MX_UINT' peek*+    } -> `CInt'+#}++mxSymbolGetNumOutputs :: SymbolHandle -> IO Int+mxSymbolGetNumOutputs symbol = do+    cnt <- checked $ mxSymbolGetNumOutputs_ symbol+    return $ fromIntegral (cnt :: MX_UINT)+--+-- {#+-- fun MXQuantizeSymbol as mxQuantizeSymbol_+--     {+--         `SymbolHandle',+--         alloca- `Ptr SymbolHandlePtr' peekSymbolHandle*,+--         `MX_UINT',+--         withSymbolHandleArray* `[SymbolHandle]',+--         `MX_UINT',+--         withStringArray* `[String]',+--         `String'+--     } -> `CInt'+-- #}
+ c-apis/MXNet/Base/Spec/HMap.hs view
@@ -0,0 +1,112 @@+{-# LANGUAGE FunctionalDependencies #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE TypeOperators #-}+{-# LANGUAGE PolyKinds, DataKinds, TypeFamilies #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE ConstraintKinds #-}+module MXNet.Base.Spec.HMap where++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)++class Pair (p :: Symbol -> * -> *) where+    key   :: p k v -> Proxy k+    value :: p k v -> v++data HMap (p :: Symbol -> * -> *) (kvs :: [*]) where+  Nil  :: Pair p => HMap p '[]+  Cons :: Pair p => p k v -> HMap p kvs -> HMap p (p k v ': kvs)++infixr 0 .& +kv .& other = Cons kv other++class Access (b :: Bool) p k v kvs | k kvs -> v where+  get' :: Proxy b -> HMap p kvs -> Proxy k -> v++instance Access True p k v (p k v ': kvs) where+  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 :: 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))++----+type family InHMap p k kvs :: Bool where+    InHMap p k '[] = False+    InHMap p k (p k v ': _) = True+    InHMap p k (_ ': kvs) = InHMap p k kvs++type family MatchHead p k v kvs where+    MatchHead p k v (p k v ': kvs) = True+    MatchHead p k v (_ ': kvs) = False+    MatchHead p k v '[] = False++type family MatchHeadKey p k kvs where+    MatchHeadKey p k (p k v ': kvs) = True+    MatchHeadKey p k (_ ': kvs) = False+    MatchHeadKey p k '[] = False++-- class Query (b :: Bool) p k v kvs where+--     query' :: Proxy b -> HMap p kvs -> Proxy k -> Maybe v++-- instance Access (MatchHead p k v kvs) p k v kvs => Query True p k v kvs where+--     query' _ hmap key = Just $ hmap ! key++-- instance Query False p k v kvs where+--     query' _ hmap key = Nothing++class Query (b :: Bool) p k v kvs where+    query' :: Proxy b -> HMap p kvs -> Proxy k -> Maybe v++instance Query True p k v (p k v ': kvs) where+    query' _ (Cons pair _) key = Just (value pair)++instance Query False p k v '[] where+    query' _ Nil key = Nothing++instance Query (MatchHead p k v kvs) p k v kvs => Query False p k v (kv ': kvs) where+    query' _ (Cons _ n) key = query' (Proxy :: Proxy (MatchHead p k v kvs)) n key++query :: forall p k v kvs. Query (MatchHead p k v kvs) p k v kvs => HMap p kvs -> Proxy k -> Maybe v+query = query' (Proxy :: Proxy (MatchHead p k v kvs))++-- note this definition 'isJust (hmap !? key)' wouldn't work, because the result type cannot+-- be inferenced.+hasKey :: forall p (k :: Symbol) kvs. KnownSymbol k => HMap p kvs -> Proxy k -> Bool+hasKey hmap key = case axiomInHMapTypeable hmap key of+                    Dict -> someTypeRep (Proxy :: Proxy (InHMap p k kvs)) == someTypeRep (Proxy :: Proxy True)++-- pop one key from the HMap+class PopKey_ (b :: Bool) p k (kvs :: [*]) where+    type PopResult_ b k kvs :: [*]+    pop' :: Proxy b -> HMap p kvs -> Proxy k -> HMap p (PopResult_ b k kvs)++instance PopKey_ False p k '[] where+    type PopResult_ False k '[] = '[]+    pop' _ Nil _ = Nil++instance PopKey_ True p k (p k v ': kvs) where+    type PopResult_ True k (p k v ': kvs) = kvs+    pop' _ (Cons _ rest) _ = rest++instance PopKey_ (MatchHeadKey p k kvs) p k kvs => PopKey_ False p k (p k' v' ': kvs) where+    type PopResult_ False k (p k' v' ': kvs) = p k' v' ': PopResult_ (MatchHeadKey p k kvs) k kvs+    pop' _ (Cons pair rest) key = Cons pair (pop' (Proxy :: Proxy (MatchHeadKey p k kvs)) rest key)++type PopKey p kvs k = PopKey_ (MatchHeadKey p k kvs) p k kvs+type PopResult p kvs k = HMap p (PopResult_ (MatchHeadKey p k kvs) k kvs)++pop :: forall p (k :: Symbol) kvs. PopKey p kvs k => HMap p kvs -> Proxy k -> PopResult p kvs k+pop = pop' (Proxy :: Proxy (MatchHeadKey p k kvs))++axiomInHMapTypeable :: KnownSymbol k => HMap p kvs -> Proxy k -> Dict (Typeable (InHMap p k kvs))+axiomInHMapTypeable _ _ = unsafeCoerce (Dict :: Dict ())
+ c-apis/MXNet/Base/Spec/Operator.hs view
@@ -0,0 +1,253 @@+{-# LANGUAGE OverloadedLabels  #-}+{-# LANGUAGE PolyKinds, DataKinds, TypeFamilies #-}+{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses #-}+{-# LANGUAGE GADTs, TypeOperators #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE PartialTypeSignatures #-}+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE ScopedTypeVariables #-}+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++instance a ~ b => IsLabel a (Proxy b) where+  fromLabel = Proxy++data EnumType (e :: [Symbol]) where+  EnumType :: (KnownSymbol v, HasEnum v e) => Proxy v -> EnumType e++type family HasEnum v e :: Constraint where+  HasEnum v e = IfThenElse (HasElement v e) (() :: Constraint) (TypeError (Text "\"" :<>: Text v :<>: Text "\" is not a valid value for the enum: [" :<>: FormatEnum e :<>: Text "]"))++type family FormatEnum (l :: [Symbol]) :: ErrorMessage where+  FormatEnum (s ': m ': n) = Text s :<>: Text ", " :<>: FormatEnum (m ': n)+  FormatEnum (s ': '[]) = Text s+  FormatEnum ('[]) = Text ""++instance (KnownSymbol v, HasEnum v e) => IsLabel v (EnumType e) where+    fromLabel = EnumType (Proxy :: Proxy v)+  +----+type family ParameterList (s :: Symbol) :: [(Symbol, Attr)]++data Attr where+  AttrReq :: (a :: *) -> Attr+  AttrOpt :: (a :: *) -> Attr++type family ParameterType (a :: Attr) :: * where+  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 '" :<>: +                              Text k :<>:+                              Text " not found")++type family FindKey (s :: Symbol) (l :: [(Symbol, k)]) (e :: ErrorMessage) :: k where+  FindKey s ('(s,i) ': _) _ = i+  FindKey s ('(z,_) ': n) e = FindKey s n e+  FindKey s '[] e = TypeError e++----++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++instance Pair (ArgOf s) where+  key   (k := v) = k+  key   (k :≅ v) = k+  value (k := v) = v+  value (k :≅ v) = v++infix 5 !, !?+infix 1 :=, :≅++(!) :: Access (MatchHead (ArgOf s) k v kvs) (ArgOf s) k v kvs +  => ArgsHMap s 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+(!?) = query++type ArgsHMap s kvs = HMap (ArgOf s) kvs+----+class Value a where+  showValue :: a -> String++instance Value (EnumType e) where+  showValue (EnumType v) = symbolVal v++instance Value Int where+  showValue = show++instance Value Bool where+  showValue = show++instance Value Float where+  showValue = show++instance Value Double where+  showValue = show++instance Value a => Value (Maybe a) where+  showValue Nothing = "None"+  showValue (Just a) = showValue a+  +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++instance ValueList True String where+  showValueList _ = id++instance Value a => ValueList False [a] where+  showValueList _ as = "[" ++ 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)]++instance Dump (ArgsHMap s '[]) 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++----+type family Subset (s1 :: [(Symbol, *)]) (s2 :: [(Symbol, *)]) :: Constraint where+  Subset '[] _ = ()+  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 '[] = '[]++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 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 FilterRequired (pl :: [(k, Attr)]) :: [(k, *)] where+  FilterRequired '[] = '[]+  FilterRequired ('(s, AttrReq t) ': pl) = '(s,t) ': FilterRequired pl+  FilterRequired (_ ': pl) = FilterRequired pl+++type family AllArgs (pl :: [(k, Attr)]) :: [(k, *)] where+  AllArgs '[] = '[]+  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 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)) +--                                         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)) +--                                         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)) +--                                         args+--                                 , HasReqArg s args ks)++type family HasArgsGen p i k args :: Constraint where+  HasArgsGen p (AttrOpt t) k args = Query (MatchHead p k t args) p k t args+  HasArgsGen p (AttrReq t) k args = (Access (MatchHead p k t args) p k t args+                                    ,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 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 HasElement (s :: k) (l :: [k]) :: Bool where+  HasElement s (s ': _) = True+  HasElement s (z ': n) = HasElement s n+  HasElement s '[] = False++type family IfThenElse (b :: Bool) (t :: k) (f :: k) :: k where+  IfThenElse True  t f = t+  IfThenElse False t f = f++-------------------------------------++type instance ParameterList "fn" = [+  '("a", AttrReq Int), +  '("b", AttrOpt String),+  '("c", AttrReq (EnumType '["c1","c2"])),+  '("d", AttrOpt (Maybe (EnumType '["c1","c2"])))+  ]+args1 :: ArgsHMap "fn" _+args1 = Nil++args2 :: ArgsHMap "fn" _+args2 = #a := 3 .& Nil++args3 :: ArgsHMap "fn" _+args3 = #a := 3 .& #b := "Hello" .& Nil++args4 :: ArgsHMap "fn" _+args4 = #a := 3 .& #c := #c1 .& Nil++args5 :: ArgsHMap "fn" _+args5 = #a := 3 .& #c := #c1 .& #d := Just #c2 .& Nil++fn1 :: Fullfilled "fn" args => ArgsHMap "fn" args -> _+fn1 args = args !? #b++fn2 :: GenQuery "fn" args '[ '("b", String), '("d", (Maybe (EnumType '["c1","c2"])))]+    => ArgsHMap "fn" args -> _+fn2 args = fn1 (#a := 3 .& #c := #c1 .& args)++fn3 :: (HasArgs "fn" args '["b", "c", "d"]) => ArgsHMap "fn" args -> _+fn3 args = fn1 (#a := 3 .& args)++fn4 :: (HasArgs "fn" args '["c", "b", "d"], WithoutArgs "fn" args '["a"]) => ArgsHMap "fn" args -> _+fn4 args = fn1 (#a := 3 .& args)
+ c-apis/MXNet/Base/Symbol.hs view
@@ -0,0 +1,418 @@+{-# LANGUAGE TypeFamilies #-}+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 MXNet.Base.Raw as I+import MXNet.Base.Types (ForeignData(..))+import Debug.Trace++newtype Symbol a = Symbol { unSymbol :: I.SymbolHandle }++instance ForeignData (Symbol a) where+    touch = I.touchSymbolHandle . unSymbol++data SymbolException = SymbolIndexOutOfBound Int Int+                     | SymbolNameNotFound String+    deriving (Typeable, Show)+instance Exception SymbolException++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)++    at'                 :: s -> String -> IO 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)++instance SymbolClass I.SymbolHandle where+    getName = I.mxSymbolGetName+    listArguments       = I.mxSymbolListArguments+    listOutputs         = I.mxSymbolListOutputs+    listAuxiliaryStates = I.mxSymbolListAuxiliaryStates+    numOutputs          = I.mxSymbolGetNumOutputs+    at sym index = 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++    inferShape sym known = do+        let (names, shapes) = unzip known+            arg_ind = scanl (+) 0 $ map length shapes+            arg_shp = concat 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++instance SymbolClass (Symbol a) where+    getName             = getName . unSymbol+    listArguments       = listArguments . unSymbol+    listOutputs         = listOutputs . unSymbol+    listAuxiliaryStates = listAuxiliaryStates . unSymbol+    numOutputs          = numOutputs . unSymbol+    at (Symbol s)       = (Symbol <$>) . at s+    group = (Symbol <$>) . group . map unSymbol+    internals           = (Symbol <$>) . internals . unSymbol +    inferShape          = inferShape  . unSymbol+++data StorageType = StorageTypeUndefined -- -1+                 | StorageTypeDefault   --  0+                 | StorageTypeRowSparse --  1+                 | StorageTypeCSR       --  2+  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)++toMXDType :: Integral a => a -> MXDType+toMXDType = toEnum . (+1) . fromIntegral++fromMXDType :: Integral a => MXDType -> a+fromMXDType = fromIntegral . (subtract 1) . fromEnum++class CustomOperation (Operation prop) => CustomOperationProp prop where+    -- list the names of inputs+    prop_list_arguments        :: prop -> [String]+    -- list the names of outputs+    prop_list_outputs          :: prop -> [String]+    -- list the names of axiliary states+    prop_list_auxiliary_states :: prop -> [String]+    -- infer the shape.+    -- params: shapes of each inputs+    -- return: shapes of inputs, outputs, auxiliary states+    prop_infer_shape :: prop -> [[Int]] -> ([[Int]], [[Int]], [[Int]])+    -- declare the dependency of symbols+    -- params: unique indices of inputs, outputs, auxiliary states+    -- return: dependant indices.+    prop_declare_backward_dependency :: prop -> [Int] -> [Int] -> [Int] -> [Int]+    prop_infer_storage_type          :: prop -> [StorageType] -> ([StorageType], [StorageType], [StorageType])+    prop_infer_storage_type prop in_stype =+        let out_stype = replicate (length (prop_list_outputs prop)) StorageTypeDefault+            aux_stype = replicate (length (prop_list_auxiliary_states prop)) StorageTypeDefault+            withAssert = assert (all (==StorageTypeDefault) in_stype)+        in withAssert (in_stype, out_stype, aux_stype)+    prop_infer_storage_type_backward :: prop ->+                                        [StorageType] ->+                                        [StorageType] ->+                                        [StorageType] ->+                                        [StorageType] ->+                                        [StorageType] ->+                                        ([StorageType], [StorageType], [StorageType], [StorageType], [StorageType])+    prop_infer_storage_type_backward prop ograd_stype in_stype out_stype igrad_stype aux_stype =+        let ograd_stype' = replicate (length ograd_stype) StorageTypeDefault+            in_stype'    = replicate (length in_stype)    StorageTypeDefault+            out_stype'   = replicate (length out_stype)   StorageTypeDefault+            igrad_stype' = replicate (length igrad_stype) StorageTypeDefault+            aux_stype'   = replicate (length aux_stype)   StorageTypeDefault+            withAssert   = let allDefault   = all (==StorageTypeDefault)+                           in assert (allDefault ograd_stype && allDefault igrad_stype)+        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)++    data Operation prop :: *+    prop_create_operator :: prop -> [[Int]] -> [MXDType] -> IO (Operation prop)++class CustomOperation op where+    forward  :: op -> [ReqEnum]+             -> [I.NDArrayHandle]+             -> [I.NDArrayHandle]+             -> [I.NDArrayHandle]+             -> Bool+             -> IO ()+    backward :: op -> [ReqEnum]+             -> [I.NDArrayHandle]+             -> [I.NDArrayHandle]+             -> [I.NDArrayHandle]+             -> [I.NDArrayHandle]+             -> [I.NDArrayHandle]+             -> IO ()++data ReqEnum = ReqNull | ReqWrite | ReqInplace | ReqAdd+    deriving (Bounded, Enum)++registerCustomOperator :: CustomOperationProp op => (String, [(String, String)] -> 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+        prop <- op_ctor $ zip keys_ vals_++        args <- mapM newCString (prop_list_arguments prop)+        ptr_args <- newArray $ args ++ [nullPtr]++        outs <- mapM newCString (prop_list_outputs prop)+        ptr_outs <- newArray $ outs ++ [nullPtr]++        auxs <- mapM newCString (prop_list_auxiliary_states prop)+        ptr_auxs <- newArray $ auxs ++ [nullPtr]++        let size = 10+        ptr_callbacks <- mallocArray size+        ptr_contexts <- newArray (replicate size nullPtr)++        allocList <- newMVar $ [castPtr ptr_args,+                                castPtr ptr_outs,+                                castPtr ptr_auxs,+                                castPtr ptr_callbacks,+                                castPtr ptr_contexts]+                               ++ map castPtr args+                               ++ map castPtr outs+                               ++ map castPtr auxs++        ptr_delete_entry                <- I.mkCustomOpDelFunc (delete_entry allocList)+        ptr_list_arguments_entry        <- I.mkCustomOpListFunc (list_entry ptr_args)+        ptr_list_outputs_entry          <- I.mkCustomOpListFunc (list_entry ptr_outs)+        ptr_list_auxiliary_states_entry <- I.mkCustomOpListFunc (list_entry ptr_auxs)+        ptr_infer_shape_entry           <- I.mkCustomOpInferShapeFunc (infer_shape_entry allocList prop)+        ptr_declare_backward_dependency_entry <- I.mkCustomOpBwdDepFunc (declare_backward_dependency_entry allocList prop)+        ptr_create_operator_entry       <- I.mkCustomOpCreateFunc (create_operator_entry prop)+        ptr_infer_type_entry            <- I.mkCustomOpInferTypeFunc (infer_type_entry prop)+        ptr_infer_storage_type_entry    <- I.mkCustomOpInferStorageTypeFunc (infer_storage_type_entry prop)+        ptr_infer_storage_type_backward_entry <- I.mkCustomOpBackwardInferStorageTypeFunc (infer_storage_type_backward_entry prop)++        pokeArray ptr_callbacks [+            castFunPtr ptr_delete_entry,+            castFunPtr ptr_list_arguments_entry,+            castFunPtr ptr_list_outputs_entry,+            castFunPtr ptr_list_auxiliary_states_entry,+            castFunPtr ptr_infer_shape_entry,+            castFunPtr ptr_declare_backward_dependency_entry,+            castFunPtr ptr_create_operator_entry,+            castFunPtr ptr_infer_type_entry,+            castFunPtr ptr_infer_storage_type_entry,+            castFunPtr ptr_infer_storage_type_backward_entry]++        poke (castPtr ret) (I.MXCallbackList size ptr_callbacks ptr_contexts)+        return 1++    delete_entry allocList _ = do+        list <- takeMVar allocList+        mapM_ free list+        return 1++    list_entry cstr out_cstr x = do+        poke out_cstr cstr+        return 1++    infer_shape_entry allocList prop num_tensor in_out_dim_tensor in_out_shapes_tensor _ = do+        let num_inp = length (prop_list_arguments prop)+            num_out = length (prop_list_outputs prop)+            num_aux = length (prop_list_auxiliary_states prop)+            num_tensor' = fromIntegral num_tensor++        assert (num_inp + num_out + num_aux == num_tensor') (return ())++        -- read dimensions of inputs+        inp_dim_0 <- peekArray num_inp in_out_dim_tensor+        -- 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)+                                [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++        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])+        modifyMVar_ allocList (return . (castPtr ptr_0 :))++        let size_UINT = sizeOf (undefined :: I.MX_UINT)+            -- all the first num_tensor' ptr refers to the shape.+            -- the last one is the end marker.+            offsets = take num_tensor' $ scanl (+) 0 $ map (size_UINT *) all_shape_sizes+            ptrs = map (plusPtr ptr_0) offsets+        pokeArray in_out_shapes_tensor ptrs+        return 1++    declare_backward_dependency_entry allocList prop grad_out data_in data_out out_num_dep out_deps _ = do+        let num_inp = length (prop_list_arguments prop)+            num_out = length (prop_list_outputs   prop)+        grad_out_inds <- peekArray num_out grad_out+        data_in_inds  <- peekArray num_inp data_in+        data_out_inds <- peekArray num_out data_out+        let deps = prop_declare_backward_dependency prop+                        (map fromIntegral grad_out_inds)+                        (map fromIntegral data_in_inds)+                        (map fromIntegral data_out_inds)+        poke out_num_dep (fromIntegral $ length deps)+        ptr_deps <- newArray (map fromIntegral deps)+        modifyMVar_ allocList (return . (castPtr ptr_deps :))++        poke out_deps ptr_deps+        return 1++    infer_type_entry prop num_tensor tensor_types _ = do+        let num_inp = length (prop_list_arguments prop)+            num_out = length (prop_list_outputs prop)+            num_aux = length (prop_list_auxiliary_states prop)+            num_tensor' = fromIntegral num_tensor+        assert (num_inp + num_out + num_aux == num_tensor') (return ())++        inp_types0 <- map toMXDType <$> peekArray num_inp tensor_types+        let (inp_types, out_types, aux_types) = prop_infer_type prop inp_types0+            all_types = map fromMXDType $ inp_types ++ out_types ++ aux_types+        pokeArray tensor_types all_types+        return 1++    infer_storage_type_entry prop num_tensor tensor_stypes _ = do+        let num_inp = length (prop_list_arguments prop)+            num_out = length (prop_list_outputs prop)+            num_aux = length (prop_list_auxiliary_states prop)+            num_tensor' = fromIntegral num_tensor+        assert (num_inp + num_out + num_aux == num_tensor') (return ())++        inp_stypes0 <- map toStorageType <$> peekArray num_inp tensor_stypes+        let (inp_stypes, out_stypes, aux_stypes) = prop_infer_storage_type prop inp_stypes0+            all_stypes = map fromStorageType $ inp_stypes ++ out_stypes ++ aux_stypes+        pokeArray tensor_stypes all_stypes+        return 1++    infer_storage_type_backward_entry prop num_tensor tensor_stypes tags _ = do+        let num_inp = length (prop_list_arguments prop)+            num_out = length (prop_list_outputs prop)+            num_aux = length (prop_list_auxiliary_states prop)+            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+            [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++        assert (length tensors == 5) (return ())+        pokeArray tensor_stypes all_stypes+        return 1++    create_operator_entry prop ctx num_inputs shapes ndims dtypes ret _ = do+        let num_inputs_ = fromIntegral num_inputs+        ndims  <- map fromIntegral <$> peekArray num_inputs_ ndims+        dtypes <- map toMXDType    <$> peekArray num_inputs_ dtypes+        ptrs   <- peekArray num_inputs_ shapes+        shapes <- mapM ((map fromIntegral <$>) . uncurry peekArray) (zip ndims ptrs)+        op <- prop_create_operator prop shapes dtypes++        let size = 3+        ptr_callbacks <- mallocArray size+        ptr_contexts  <- newArray (replicate size nullPtr)+        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)+        ptr_func_backward_entry <- I.mkCustomFunctionBwdFunc (func_backward_entry op)+        pokeArray ptr_callbacks [+            castFunPtr ptr_delete_entry,+            castFunPtr ptr_func_forward_entry,+            castFunPtr ptr_func_backward_entry]++        poke ret (I.MXCallbackList size ptr_callbacks ptr_contexts)+        return 1++    func_forward_entry op num_ndarray ndarrays tags reqs is_train _ = do+        let num_ndarray_ = fromIntegral num_ndarray+        ndarrays <- peekArray num_ndarray_ ndarrays >>= mapM I.newNDArrayHandle+        tags     <- peekArray num_ndarray_ tags++        let tensors = V.map reverse $ V.create $ do+                        vec <- VM.replicate 5 []+                        forM (zip tags ndarrays) $ \(ind, hdl) -> do+                            let ind_ = fromIntegral ind+                            lst <- VM.read vec ind_+                            VM.write vec ind_ (hdl : lst)+                        return vec++        let in_data  = tensors ! 0+            out_data = tensors ! 1+            aux      = tensors ! 4++        reqs <- map (toEnum . fromIntegral) <$> peekArray (length out_data) reqs :: IO [ReqEnum]+        forward op reqs in_data out_data aux (is_train == 1)+        return 1++    func_backward_entry op num_ndarray ndarrays tags reqs is_train _ = do+        let num_ndarray_ = fromIntegral num_ndarray+        ndarrays <- peekArray num_ndarray_ ndarrays >>= mapM I.newNDArrayHandle+        tags     <- peekArray num_ndarray_ tags++        let tensors = V.map reverse $ V.create $ do+                        vec <- VM.replicate 5 []+                        forM (zip tags ndarrays) $ \(ind, hdl) -> do+                            let ind_ = fromIntegral ind+                            lst <- VM.read vec ind_+                            VM.write vec ind_ (hdl : lst)+                        return vec++        let in_data  = tensors ! 0+            out_data = tensors ! 1+            in_grad  = tensors ! 2+            out_grad = tensors ! 3+            aux      = tensors ! 4++        reqs <- map (toEnum . fromIntegral) <$> peekArray (length out_data) reqs+        backward op reqs in_data out_data in_grad out_grad aux+        return 1++    (!) = (V.!)
+ c-apis/MXNet/Base/Types.hs view
@@ -0,0 +1,35 @@+{-# 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)++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++  flag :: a -> Int++instance DType Float where+  type DTypeName Float = "float32"+  flag _ = 0    -- mshadow::kFloat32++instance DType Double where+  type DTypeName Double = "float64"+  flag _ = 1    -- mshadow::kFloat64++contextCPU :: Context+contextCPU = Context 1 0++contextGPU0 :: Context+contextGPU0 = Context 2 0++class ForeignData a where+    touch :: a -> IO ()
+ cmdline/Main.hs view
@@ -0,0 +1,417 @@+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 MXNet.Base.Raw++_module_ = "Main"++data Arguments = Arguments {+    output_dir :: FilePath+}++args_spec = Arguments+         <$> strOption (long "output" <> short 'o' <> value "operators" <> metavar "OUTPUT-DIR")++main = do+    updateGlobalLogger _module_ (setLevel INFO)+    args <- execParser opts+    let base = output_dir args </> "MXNet" </> "Base" </> "Operators"+    createDirectoryIfMissing True base++    ops  <- mxSymbolListAtomicSymbolCreators++    infoM _module_ "Generating Symbol operators..."+    symbols <- concat <$> mapM genSymOp ops+    writeFile (base </> "Symbol.hs") $ prettyPrint (modSymbol symbols)++    infoM _module_ "Generating NDArray operators..."+    arrays  <- concat <$> mapM genArrOp ops+    writeFile (base </> "NDArray.hs") $ prettyPrint (modArray arrays)++  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"+                , simpleImport "MXNet.Base.Spec.Operator"+                , simpleImport "MXNet.Base.Spec.HMap"+                , simpleImportVars "Data.Maybe" ["catMaybes", "fromMaybe"]]++makeParamInst :: String -> [ResolvedType] -> Bool -> Decl ()+makeParamInst symname typs symbolapi =+    TypeInsDecl () (tyApp (tyCon $ unQual $ name "ParameterList") (tyPromotedStr symname_with_appendix))+                   (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++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)++genSymOp :: AtomicSymbolCreator -> IO [Decl ()]+genSymOp sc = do+    (symname, desc, argname, argtype, argdesc, key_var_num_args, rettyp) <- mxSymbolGetAtomicSymbolInfo sc+    if symname `elem` ["_Native", "_NDArray"] then+        return []+    else do+        let symname_ = normalizeName symname+            (errs, scalarTypes, tensorTypes, arrayTypes) = execWriter $ zipWithM_ (resolveHaskellType True) 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)+            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) True+                sig = makeSignature symname_ GenSymbolOp $ +                        -- the "Custom" is a little special, because it allow extra arguments+                        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"],+                                     appA (name "Dump") [ tyParen $+                                        (tyCon $ unQual $ name "PopResult") `tyApp` +                                        argOfCustom `tyApp` +                                        tyVarIdent "args" `tyApp` +                                        tyPromotedStr "data"]]+                            else []+            let fun = sfun (name symname_) [name "name", 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"))+                        -- catMaybes+                        --    [("KEY",) . showValue <$> (args !? #KEY :: Maybe VALUE_TYPE),+                        --     ... ]+                        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]+                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"+                            `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"))]+                          _ -> [])+                        (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") ])+            return [paramListInst, sig, fun]++genArrOp :: AtomicSymbolCreator -> IO [Decl ()]+genArrOp sc = do+    (symname, desc, argname0, argtype0, argdesc, key_var_num_args, rettyp) <- mxSymbolGetAtomicSymbolInfo sc++    -- 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)++    if symname `elem` ["_Native", "_NDArray", "Custom"] then+        return []+    else do+        let symname_ = normalizeName symname+            (errs, scalarTypes, tensorTypes, arrayTypes) = execWriter $ zipWithM_ (resolveHaskellType False) 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 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]++normalizeName :: String -> String+normalizeName name@(c:cs)+    | isUpper c = '_' : name+    | name == "where" = "_where"+    | otherwise = name++data ParamDesc = ParamDescItem String | ParamDescList Bool [String] deriving (Eq, Show)++type ResolvedType = (String, Type (), Type ())+resolveHaskellType :: Bool -> String -> String -> Writer ([(String, String)], [ResolvedType], [ResolvedType], [ResolvedType]) ()+resolveHaskellType asSymbol 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+                --+                -- ndarray 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++                fallThrough t = fail $ printf "Unknown type: arg %s(%s)." symname desc++            case head fields of+                ParamDescItem "Shape(tuple)"        -> scalar $ tyList $ tyCon $ unQual $ name "Int"+                ParamDescItem "int"                 -> scalar $ tyCon $ unQual $ name "Int"+                ParamDescItem "int (non-negative)"  -> scalar $ tyCon $ unQual $ name "Int"+                ParamDescItem "long (non-negative)" -> scalar $ tyCon $ unQual $ name "Int"+                ParamDescItem "boolean"             -> scalar $ tyCon $ unQual $ name "Bool"+                ParamDescItem "float"               -> scalar $ tyCon $ unQual $ name "Float"+                ParamDescItem "double"              -> scalar $ tyCon $ unQual $ name "Double"+                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 "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")+                ParamDescItem "boolean or None"     -> scalar $ tyApp (tyCon $ unQual $ name "Maybe") (tyCon $ unQual $ name "Bool")+                ParamDescItem "Shape or None"       -> scalar $ tyApp (tyCon $ unQual $ name "Maybe") (tyList $ tyCon $ unQual $ name "Int")+                ParamDescItem "tuple of <float>"    -> scalar $ tyList $ tyCon $ unQual $ name "Float"+                ParamDescItem "tuple of <double>"   -> scalar $ tyList $ tyCon $ unQual $ name "Double"+                ParamDescList hasnone vs -> do+                    let vsprom = map tyPromotedStr vs+                        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)++typedesc = do+    -- since 1.3, there are types starting with ',', and it implies 'int' type.+    def <- (char ',' >> return [ParamDescItem "int"]) <++ return []+    ds <- sepBy (skipSpaces >> (list1 +++ list2 +++ item)) (char ',')+    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` " _-()=[]<>'.")++unQual = UnQual ()+unkindedVar = UnkindedVar ()++tyCon = TyCon ()+tyVarSymbol = TyVar () . Symbol ()+tyVarIdent = TyVar () . Ident ()+tyApp = TyApp ()+tyFun = TyFun ()+tySig names types = TypeSig () names types+tyList = TyList ()+tyVar = TyVar ()+tyParen = TyParen ()++tyPromotedInteger s = TyPromoted () (PromotedInteger () s (show s))+tyPromotedStr s     = TyPromoted () (PromotedString () s s)+tyPromotedList s    = TyPromoted () (PromotedList () True s)+tyPromotedTuple s   = TyPromoted () (PromotedTuple () s)++tyForall vars cxt typ = TyForall () vars_ cxt_ typ+  where+    vars_ = if null vars then Nothing else Just vars+    cxt_  = if cxt == CxEmpty () then Nothing else Just cxt++cxSingle = CxSingle ()+cxTuple  = CxTuple ()++appA = AppA ()++tupleSection = TupleSection () Boxed++con = Con ()++simpleImport mod = ImportDecl {+    importAnn = (),+    importModule = ModuleName () mod,+    importQualified = False,+    importSrc = False,+    importSafe = False,+    importPkg = Nothing,+    importAs = Nothing,+    importSpecs = Nothing+}++simpleImportVars mod vars = ImportDecl {+    importAnn = (),+    importModule = ModuleName () mod,+    importQualified = False,+    importSrc = False,+    importSafe = False,+    importPkg = Nothing,+    importAs = Nothing,+    importSpecs = Just $ ImportSpecList () False [IVar () $ Ident () var | var <- vars]+}
+ fei-base.cabal view
@@ -0,0 +1,105 @@+cabal-version:       2.2+name:                fei-base+version:             0.2.0.0+synopsis:            FFI to MXNet+description:         This package provides a FFI wrap of MXNet, including c-apis and symbol/array/executor operations.+homepage:+license:             BSD-3-Clause+license-file:        LICENSE+author:              Jiasen Wu+maintainer:          jiasenwu@hotmail.com+copyright:           2018 Jiasen Wu+category:            Machine Learning, AI+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+  Default: False+}++Flag MXNet_1_0 {+  Description: With MXNet 1.0.x operators+  Default: False+}++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+  }+  elif flag(MXNet_1_5) {+      hs-source-dirs:  ops/1.5+  }+  build-depends:       base >= 4.7 && < 5,+                       c2hs-extra == 0.1.0.1,+                       tuple-ops == 0.0.0.3,+                       vector >= 0.11 && < 0.13,+                       constraints,+                       repa+  default-language:    Haskell2010+  Build-tools:         c2hs+  default-extensions:  FlexibleContexts,+                       GADTs,+                       StandaloneDeriving,+                       DeriveGeneric,+                       GeneralizedNewtypeDeriving,+                       ExplicitForAll,+                       DataKinds,+                       TypeFamilies,+                       OverloadedLabels,+                       TupleSections+  exposed-modules:     MXNet.Base,+                       MXNet.Base.Raw,+                       MXNet.Base.Types,+                       MXNet.Base.Symbol,+                       MXNet.Base.NDArray,+                       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+  }+  other-modules:       MXNet.Base.Raw.Common,+                       MXNet.Base.Raw.NDArray,+                       MXNet.Base.Raw.Symbol,+                       MXNet.Base.Raw.Executor,+                       MXNet.Base.Raw.DataIter+  extra-libraries:     mxnet++executable mxnet-op-gen+  hs-source-dirs:      cmdline+  main-is:             Main.hs+  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+  default-language:    Haskell2010+  default-extensions:  FlexibleContexts+  extra-libraries:     mxnet++source-repository head+  type:     git+  location: https://github.com/pierric/fei-base
+ ops/1.0/MXNet/Base/Operators/NDArray.hs view
@@ -0,0 +1,16434 @@+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 ()
+ ops/1.0/MXNet/Base/Operators/Symbol.hs view
@@ -0,0 +1,9339 @@+module MXNet.Base.Operators.Symbol where+import MXNet.Base.Raw+import MXNet.Base.Spec.Operator+import MXNet.Base.Spec.HMap+import Data.Maybe (catMaybes, fromMaybe)++type instance ParameterList "broadcast_power(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_power ::+                forall args . Fullfilled "broadcast_power(symbol)" args =>+                  String ->+                    ArgsHMap "broadcast_power(symbol)" args -> IO SymbolHandle+broadcast_power name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_power"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_power(symbol)" =+     '[]++_backward_broadcast_power ::+                          forall args .+                            Fullfilled "_backward_broadcast_power(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_broadcast_power(symbol)" args ->+                                IO SymbolHandle+_backward_broadcast_power name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_power"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_maximum(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_maximum ::+                  forall args . Fullfilled "broadcast_maximum(symbol)" args =>+                    String ->+                      ArgsHMap "broadcast_maximum(symbol)" args -> IO SymbolHandle+broadcast_maximum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_maximum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_maximum(symbol)" =+     '[]++_backward_broadcast_maximum ::+                            forall args .+                              Fullfilled "_backward_broadcast_maximum(symbol)" args =>+                              String ->+                                ArgsHMap "_backward_broadcast_maximum(symbol)" args ->+                                  IO SymbolHandle+_backward_broadcast_maximum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_maximum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_minimum(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_minimum ::+                  forall args . Fullfilled "broadcast_minimum(symbol)" args =>+                    String ->+                      ArgsHMap "broadcast_minimum(symbol)" args -> IO SymbolHandle+broadcast_minimum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_minimum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_minimum(symbol)" =+     '[]++_backward_broadcast_minimum ::+                            forall args .+                              Fullfilled "_backward_broadcast_minimum(symbol)" args =>+                              String ->+                                ArgsHMap "_backward_broadcast_minimum(symbol)" args ->+                                  IO SymbolHandle+_backward_broadcast_minimum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_minimum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_hypot(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_hypot ::+                forall args . Fullfilled "broadcast_hypot(symbol)" args =>+                  String ->+                    ArgsHMap "broadcast_hypot(symbol)" args -> IO SymbolHandle+broadcast_hypot name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_hypot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_hypot(symbol)" =+     '[]++_backward_broadcast_hypot ::+                          forall args .+                            Fullfilled "_backward_broadcast_hypot(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_broadcast_hypot(symbol)" args ->+                                IO SymbolHandle+_backward_broadcast_hypot name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_hypot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_equal ::+       forall args . Fullfilled "_equal(symbol)" args =>+         String -> ArgsHMap "_equal(symbol)" args -> IO SymbolHandle+_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_not_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_not_equal ::+           forall args . Fullfilled "_not_equal(symbol)" args =>+             String -> ArgsHMap "_not_equal(symbol)" args -> IO SymbolHandle+_not_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_not_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_greater(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_greater ::+         forall args . Fullfilled "_greater(symbol)" args =>+           String -> ArgsHMap "_greater(symbol)" args -> IO SymbolHandle+_greater name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_greater_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_greater_equal ::+               forall args . Fullfilled "_greater_equal(symbol)" args =>+                 String -> ArgsHMap "_greater_equal(symbol)" args -> IO SymbolHandle+_greater_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_lesser(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_lesser ::+        forall args . Fullfilled "_lesser(symbol)" args =>+          String -> ArgsHMap "_lesser(symbol)" args -> IO SymbolHandle+_lesser name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_lesser_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_lesser_equal ::+              forall args . Fullfilled "_lesser_equal(symbol)" args =>+                String -> ArgsHMap "_lesser_equal(symbol)" args -> IO SymbolHandle+_lesser_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_power(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_power ::+       forall args . Fullfilled "_power(symbol)" args =>+         String -> ArgsHMap "_power(symbol)" args -> IO SymbolHandle+_power name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_power"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_power(symbol)" = '[]++_backward_power ::+                forall args . Fullfilled "_backward_power(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_power(symbol)" args -> IO SymbolHandle+_backward_power name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_power"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_maximum(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_maximum ::+         forall args . Fullfilled "_maximum(symbol)" args =>+           String -> ArgsHMap "_maximum(symbol)" args -> IO SymbolHandle+_maximum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_maximum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_maximum(symbol)" = '[]++_backward_maximum ::+                  forall args . Fullfilled "_backward_maximum(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_maximum(symbol)" args -> IO SymbolHandle+_backward_maximum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_maximum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_minimum(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_minimum ::+         forall args . Fullfilled "_minimum(symbol)" args =>+           String -> ArgsHMap "_minimum(symbol)" args -> IO SymbolHandle+_minimum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minimum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_minimum(symbol)" = '[]++_backward_minimum ::+                  forall args . Fullfilled "_backward_minimum(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_minimum(symbol)" args -> IO SymbolHandle+_backward_minimum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_minimum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_hypot(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_hypot ::+       forall args . Fullfilled "_hypot(symbol)" args =>+         String -> ArgsHMap "_hypot(symbol)" args -> IO SymbolHandle+_hypot name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_hypot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_hypot(symbol)" = '[]++_backward_hypot ::+                forall args . Fullfilled "_backward_hypot(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_hypot(symbol)" args -> IO SymbolHandle+_backward_hypot name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_hypot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_square_sum(symbol)" =+     '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++_square_sum ::+            forall args . Fullfilled "_square_sum(symbol)" args =>+              String -> ArgsHMap "_square_sum(symbol)" args -> IO SymbolHandle+_square_sum name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_square_sum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_square_sum(symbol)" = '[]++_backward_square_sum ::+                     forall args . Fullfilled "_backward_square_sum(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_square_sum(symbol)" args -> IO SymbolHandle+_backward_square_sum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_square_sum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "add_n(symbol)" =+     '[ '("args", AttrOpt [SymbolHandle])]++add_n ::+      forall args . Fullfilled "add_n(symbol)" args =>+        String -> ArgsHMap "add_n(symbol)" args -> IO SymbolHandle+add_n name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "add_n"+         sym <- if hasKey args #num_args then+                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals+                  else+                  mxSymbolCreateAtomicSymbol (fromOpHandle op)+                    ("num_args" : scalarkeys)+                    (showValue (length array) : scalarvals)+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_zeros(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]++_zeros ::+       forall args . Fullfilled "_zeros(symbol)" args =>+         String -> ArgsHMap "_zeros(symbol)" args -> IO SymbolHandle+_zeros name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_zeros"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_ones(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]++_ones ::+      forall args . Fullfilled "_ones(symbol)" args =>+        String -> ArgsHMap "_ones(symbol)" args -> IO SymbolHandle+_ones name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_ones"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_full(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),+        '("value", AttrReq Double)]++_full ::+      forall args . Fullfilled "_full(symbol)" args =>+        String -> ArgsHMap "_full(symbol)" args -> IO SymbolHandle+_full name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"])),+               ("value",) . showValue <$> (args !? #value :: Maybe Double)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_full"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_arange(symbol)" =+     '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)),+        '("step", AttrOpt Double), '("repeat", AttrOpt Int),+        '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "uint8"]))]++_arange ::+        forall args . Fullfilled "_arange(symbol)" args =>+          String -> ArgsHMap "_arange(symbol)" args -> IO SymbolHandle+_arange name args+  = let scalarArgs+          = catMaybes+              [("start",) . showValue <$> (args !? #start :: Maybe Double),+               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),+               ("step",) . showValue <$> (args !? #step :: Maybe Double),+               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_arange"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "zeros_like(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++zeros_like ::+           forall args . Fullfilled "zeros_like(symbol)" args =>+             String -> ArgsHMap "zeros_like(symbol)" args -> IO SymbolHandle+zeros_like name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "zeros_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "ones_like(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++ones_like ::+          forall args . Fullfilled "ones_like(symbol)" args =>+            String -> ArgsHMap "ones_like(symbol)" args -> IO SymbolHandle+ones_like name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ones_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_add(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_add ::+              forall args . Fullfilled "broadcast_add(symbol)" args =>+                String -> ArgsHMap "broadcast_add(symbol)" args -> IO SymbolHandle+broadcast_add name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_add"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_add(symbol)" = '[]++_backward_broadcast_add ::+                        forall args . Fullfilled "_backward_broadcast_add(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_broadcast_add(symbol)" args -> IO SymbolHandle+_backward_broadcast_add name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_add"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_sub(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_sub ::+              forall args . Fullfilled "broadcast_sub(symbol)" args =>+                String -> ArgsHMap "broadcast_sub(symbol)" args -> IO SymbolHandle+broadcast_sub name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_sub"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_sub(symbol)" = '[]++_backward_broadcast_sub ::+                        forall args . Fullfilled "_backward_broadcast_sub(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_broadcast_sub(symbol)" args -> IO SymbolHandle+_backward_broadcast_sub name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_sub"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_mul(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_mul ::+              forall args . Fullfilled "broadcast_mul(symbol)" args =>+                String -> ArgsHMap "broadcast_mul(symbol)" args -> IO SymbolHandle+broadcast_mul name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_mul"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_mul(symbol)" = '[]++_backward_broadcast_mul ::+                        forall args . Fullfilled "_backward_broadcast_mul(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_broadcast_mul(symbol)" args -> IO SymbolHandle+_backward_broadcast_mul name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_mul"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_div(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_div ::+              forall args . Fullfilled "broadcast_div(symbol)" args =>+                String -> ArgsHMap "broadcast_div(symbol)" args -> IO SymbolHandle+broadcast_div name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_div"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_div(symbol)" = '[]++_backward_broadcast_div ::+                        forall args . Fullfilled "_backward_broadcast_div(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_broadcast_div(symbol)" args -> IO SymbolHandle+_backward_broadcast_div name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_div"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_mod(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_mod ::+              forall args . Fullfilled "broadcast_mod(symbol)" args =>+                String -> ArgsHMap "broadcast_mod(symbol)" args -> IO SymbolHandle+broadcast_mod name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_mod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_mod(symbol)" = '[]++_backward_broadcast_mod ::+                        forall args . Fullfilled "_backward_broadcast_mod(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_broadcast_mod(symbol)" args -> IO SymbolHandle+_backward_broadcast_mod name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_mod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_gemm(symbol)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("alpha", AttrOpt Double), '("beta", AttrOpt Double),+        '("_A", AttrOpt SymbolHandle), '("_B", AttrOpt SymbolHandle),+        '("_C", AttrOpt SymbolHandle)]++_linalg_gemm ::+             forall args . Fullfilled "_linalg_gemm(symbol)" args =>+               String -> ArgsHMap "_linalg_gemm(symbol)" args -> IO SymbolHandle+_linalg_gemm name args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Double)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),+               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle),+               ("_C",) <$> (args !? #_C :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gemm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_gemm(symbol)" = '[]++_backward_linalg_gemm ::+                      forall args . Fullfilled "_backward_linalg_gemm(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_linalg_gemm(symbol)" args -> IO SymbolHandle+_backward_linalg_gemm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gemm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_gemm2(symbol)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("alpha", AttrOpt Double), '("_A", AttrOpt SymbolHandle),+        '("_B", AttrOpt SymbolHandle)]++_linalg_gemm2 ::+              forall args . Fullfilled "_linalg_gemm2(symbol)" args =>+                String -> ArgsHMap "_linalg_gemm2(symbol)" args -> IO SymbolHandle+_linalg_gemm2 name args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),+               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gemm2"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_gemm2(symbol)" = '[]++_backward_linalg_gemm2 ::+                       forall args . Fullfilled "_backward_linalg_gemm2(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_linalg_gemm2(symbol)" args -> IO SymbolHandle+_backward_linalg_gemm2 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gemm2"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_potrf(symbol)" =+     '[ '("_A", AttrOpt SymbolHandle)]++_linalg_potrf ::+              forall args . Fullfilled "_linalg_potrf(symbol)" args =>+                String -> ArgsHMap "_linalg_potrf(symbol)" args -> IO SymbolHandle+_linalg_potrf name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_potrf"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_potrf(symbol)" = '[]++_backward_linalg_potrf ::+                       forall args . Fullfilled "_backward_linalg_potrf(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_linalg_potrf(symbol)" args -> IO SymbolHandle+_backward_linalg_potrf name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_potrf"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_potri(symbol)" =+     '[ '("_A", AttrOpt SymbolHandle)]++_linalg_potri ::+              forall args . Fullfilled "_linalg_potri(symbol)" args =>+                String -> ArgsHMap "_linalg_potri(symbol)" args -> IO SymbolHandle+_linalg_potri name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_potri"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_potri(symbol)" = '[]++_backward_linalg_potri ::+                       forall args . Fullfilled "_backward_linalg_potri(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_linalg_potri(symbol)" args -> IO SymbolHandle+_backward_linalg_potri name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_potri"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_trmm(symbol)" =+     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),+        '("alpha", AttrOpt Double), '("_A", AttrOpt SymbolHandle),+        '("_B", AttrOpt SymbolHandle)]++_linalg_trmm ::+             forall args . Fullfilled "_linalg_trmm(symbol)" args =>+               String -> ArgsHMap "_linalg_trmm(symbol)" args -> IO SymbolHandle+_linalg_trmm name args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),+               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_trmm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_trmm(symbol)" = '[]++_backward_linalg_trmm ::+                      forall args . Fullfilled "_backward_linalg_trmm(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_linalg_trmm(symbol)" args -> IO SymbolHandle+_backward_linalg_trmm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_trmm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_trsm(symbol)" =+     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),+        '("alpha", AttrOpt Double), '("_A", AttrOpt SymbolHandle),+        '("_B", AttrOpt SymbolHandle)]++_linalg_trsm ::+             forall args . Fullfilled "_linalg_trsm(symbol)" args =>+               String -> ArgsHMap "_linalg_trsm(symbol)" args -> IO SymbolHandle+_linalg_trsm name args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),+               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_trsm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_trsm(symbol)" = '[]++_backward_linalg_trsm ::+                      forall args . Fullfilled "_backward_linalg_trsm(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_linalg_trsm(symbol)" args -> IO SymbolHandle+_backward_linalg_trsm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_trsm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_sumlogdiag(symbol)" =+     '[ '("_A", AttrOpt SymbolHandle)]++_linalg_sumlogdiag ::+                   forall args . Fullfilled "_linalg_sumlogdiag(symbol)" args =>+                     String ->+                       ArgsHMap "_linalg_sumlogdiag(symbol)" args -> IO SymbolHandle+_linalg_sumlogdiag name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_sumlogdiag"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_sumlogdiag(symbol)" =+     '[]++_backward_linalg_sumlogdiag ::+                            forall args .+                              Fullfilled "_backward_linalg_sumlogdiag(symbol)" args =>+                              String ->+                                ArgsHMap "_backward_linalg_sumlogdiag(symbol)" args ->+                                  IO SymbolHandle+_backward_linalg_sumlogdiag name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_sumlogdiag"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_syrk(symbol)" =+     '[ '("transpose", AttrOpt Bool), '("alpha", AttrOpt Double),+        '("_A", AttrOpt SymbolHandle)]++_linalg_syrk ::+             forall args . Fullfilled "_linalg_syrk(symbol)" args =>+               String -> ArgsHMap "_linalg_syrk(symbol)" args -> IO SymbolHandle+_linalg_syrk name args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_syrk"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_syrk(symbol)" = '[]++_backward_linalg_syrk ::+                      forall args . Fullfilled "_backward_linalg_syrk(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_linalg_syrk(symbol)" args -> IO SymbolHandle+_backward_linalg_syrk name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_syrk"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_gelqf(symbol)" =+     '[ '("_A", AttrOpt SymbolHandle)]++_linalg_gelqf ::+              forall args . Fullfilled "_linalg_gelqf(symbol)" args =>+                String -> ArgsHMap "_linalg_gelqf(symbol)" args -> IO SymbolHandle+_linalg_gelqf name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gelqf"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_gelqf(symbol)" = '[]++_backward_linalg_gelqf ::+                       forall args . Fullfilled "_backward_linalg_gelqf(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_linalg_gelqf(symbol)" args -> IO SymbolHandle+_backward_linalg_gelqf name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gelqf"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_syevd(symbol)" =+     '[ '("_A", AttrOpt SymbolHandle)]++_linalg_syevd ::+              forall args . Fullfilled "_linalg_syevd(symbol)" args =>+                String -> ArgsHMap "_linalg_syevd(symbol)" args -> IO SymbolHandle+_linalg_syevd name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_syevd"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_syevd(symbol)" = '[]++_backward_linalg_syevd ::+                       forall args . Fullfilled "_backward_linalg_syevd(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_linalg_syevd(symbol)" args -> IO SymbolHandle+_backward_linalg_syevd name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_syevd"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "cast_storage(symbol)" =+     '[ '("stype",+          AttrReq (EnumType '["csr", "default", "row_sparse"])),+        '("data", AttrOpt SymbolHandle)]++cast_storage ::+             forall args . Fullfilled "cast_storage(symbol)" args =>+               String -> ArgsHMap "cast_storage(symbol)" args -> IO SymbolHandle+cast_storage name args+  = let scalarArgs+          = catMaybes+              [("stype",) . showValue <$>+                 (args !? #stype ::+                    Maybe (EnumType '["csr", "default", "row_sparse"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cast_storage"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_equal_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_equal_scalar ::+              forall args . Fullfilled "_equal_scalar(symbol)" args =>+                String -> ArgsHMap "_equal_scalar(symbol)" args -> IO SymbolHandle+_equal_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_equal_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_not_equal_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_not_equal_scalar ::+                  forall args . Fullfilled "_not_equal_scalar(symbol)" args =>+                    String ->+                      ArgsHMap "_not_equal_scalar(symbol)" args -> IO SymbolHandle+_not_equal_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_not_equal_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_greater_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_greater_scalar ::+                forall args . Fullfilled "_greater_scalar(symbol)" args =>+                  String ->+                    ArgsHMap "_greater_scalar(symbol)" args -> IO SymbolHandle+_greater_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_greater_equal_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_greater_equal_scalar ::+                      forall args . Fullfilled "_greater_equal_scalar(symbol)" args =>+                        String ->+                          ArgsHMap "_greater_equal_scalar(symbol)" args -> IO SymbolHandle+_greater_equal_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_equal_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_lesser_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_lesser_scalar ::+               forall args . Fullfilled "_lesser_scalar(symbol)" args =>+                 String -> ArgsHMap "_lesser_scalar(symbol)" args -> IO SymbolHandle+_lesser_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_lesser_equal_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_lesser_equal_scalar ::+                     forall args . Fullfilled "_lesser_equal_scalar(symbol)" args =>+                       String ->+                         ArgsHMap "_lesser_equal_scalar(symbol)" args -> IO SymbolHandle+_lesser_equal_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_equal_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "relu(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++relu ::+     forall args . Fullfilled "relu(symbol)" args =>+       String -> ArgsHMap "relu(symbol)" args -> IO SymbolHandle+relu name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "relu"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_relu(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_relu ::+               forall args . Fullfilled "_backward_relu(symbol)" args =>+                 String -> ArgsHMap "_backward_relu(symbol)" args -> IO SymbolHandle+_backward_relu name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_relu"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sigmoid(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++sigmoid ::+        forall args . Fullfilled "sigmoid(symbol)" args =>+          String -> ArgsHMap "sigmoid(symbol)" args -> IO SymbolHandle+sigmoid name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sigmoid"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sigmoid(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_sigmoid ::+                  forall args . Fullfilled "_backward_sigmoid(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_sigmoid(symbol)" args -> IO SymbolHandle+_backward_sigmoid name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sigmoid"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_copy(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++_copy ::+      forall args . Fullfilled "_copy(symbol)" args =>+        String -> ArgsHMap "_copy(symbol)" args -> IO SymbolHandle+_copy name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_copy"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_copy(symbol)" = '[]++_backward_copy ::+               forall args . Fullfilled "_backward_copy(symbol)" args =>+                 String -> ArgsHMap "_backward_copy(symbol)" args -> IO SymbolHandle+_backward_copy name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_copy"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_BlockGrad(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++_BlockGrad ::+           forall args . Fullfilled "_BlockGrad(symbol)" args =>+             String -> ArgsHMap "_BlockGrad(symbol)" args -> IO SymbolHandle+_BlockGrad name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BlockGrad"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "make_loss(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++make_loss ::+          forall args . Fullfilled "make_loss(symbol)" args =>+            String -> ArgsHMap "make_loss(symbol)" args -> IO SymbolHandle+make_loss name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "make_loss"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_identity_with_attr_like_rhs(symbol)"+     =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_identity_with_attr_like_rhs ::+                             forall args .+                               Fullfilled "_identity_with_attr_like_rhs(symbol)" args =>+                               String ->+                                 ArgsHMap "_identity_with_attr_like_rhs(symbol)" args ->+                                   IO SymbolHandle+_identity_with_attr_like_rhs name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_identity_with_attr_like_rhs"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "reshape_like(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++reshape_like ::+             forall args . Fullfilled "reshape_like(symbol)" args =>+               String -> ArgsHMap "reshape_like(symbol)" args -> IO SymbolHandle+reshape_like name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reshape_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Cast(symbol)" =+     '[ '("dtype",+          AttrReq+            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),+        '("data", AttrOpt SymbolHandle)]++_Cast ::+      forall args . Fullfilled "_Cast(symbol)" args =>+        String -> ArgsHMap "_Cast(symbol)" args -> IO SymbolHandle+_Cast name args+  = let scalarArgs+          = catMaybes+              [("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Cast"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_cast(symbol)" = '[]++_backward_cast ::+               forall args . Fullfilled "_backward_cast(symbol)" args =>+                 String -> ArgsHMap "_backward_cast(symbol)" args -> IO SymbolHandle+_backward_cast name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cast"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "negative(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++negative ::+         forall args . Fullfilled "negative(symbol)" args =>+           String -> ArgsHMap "negative(symbol)" args -> IO SymbolHandle+negative name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "negative"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "reciprocal(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++reciprocal ::+           forall args . Fullfilled "reciprocal(symbol)" args =>+             String -> ArgsHMap "reciprocal(symbol)" args -> IO SymbolHandle+reciprocal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reciprocal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_reciprocal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_reciprocal ::+                     forall args . Fullfilled "_backward_reciprocal(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_reciprocal(symbol)" args -> IO SymbolHandle+_backward_reciprocal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_reciprocal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "abs(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++abs ::+    forall args . Fullfilled "abs(symbol)" args =>+      String -> ArgsHMap "abs(symbol)" args -> IO SymbolHandle+abs name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "abs"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_abs(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_abs ::+              forall args . Fullfilled "_backward_abs(symbol)" args =>+                String -> ArgsHMap "_backward_abs(symbol)" args -> IO SymbolHandle+_backward_abs name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_abs"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sign(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++sign ::+     forall args . Fullfilled "sign(symbol)" args =>+       String -> ArgsHMap "sign(symbol)" args -> IO SymbolHandle+sign name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sign"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sign(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_sign ::+               forall args . Fullfilled "_backward_sign(symbol)" args =>+                 String -> ArgsHMap "_backward_sign(symbol)" args -> IO SymbolHandle+_backward_sign name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sign"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "round(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++round ::+      forall args . Fullfilled "round(symbol)" args =>+        String -> ArgsHMap "round(symbol)" args -> IO SymbolHandle+round name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "round"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "rint(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++rint ::+     forall args . Fullfilled "rint(symbol)" args =>+       String -> ArgsHMap "rint(symbol)" args -> IO SymbolHandle+rint name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rint"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "ceil(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++ceil ::+     forall args . Fullfilled "ceil(symbol)" args =>+       String -> ArgsHMap "ceil(symbol)" args -> IO SymbolHandle+ceil name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ceil"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "floor(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++floor ::+      forall args . Fullfilled "floor(symbol)" args =>+        String -> ArgsHMap "floor(symbol)" args -> IO SymbolHandle+floor name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "floor"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "trunc(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++trunc ::+      forall args . Fullfilled "trunc(symbol)" args =>+        String -> ArgsHMap "trunc(symbol)" args -> IO SymbolHandle+trunc name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "trunc"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "fix(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++fix ::+    forall args . Fullfilled "fix(symbol)" args =>+      String -> ArgsHMap "fix(symbol)" args -> IO SymbolHandle+fix name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "fix"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "square(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++square ::+       forall args . Fullfilled "square(symbol)" args =>+         String -> ArgsHMap "square(symbol)" args -> IO SymbolHandle+square name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "square"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_square(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_square ::+                 forall args . Fullfilled "_backward_square(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_square(symbol)" args -> IO SymbolHandle+_backward_square name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_square"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sqrt(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++sqrt ::+     forall args . Fullfilled "sqrt(symbol)" args =>+       String -> ArgsHMap "sqrt(symbol)" args -> IO SymbolHandle+sqrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sqrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sqrt(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_sqrt ::+               forall args . Fullfilled "_backward_sqrt(symbol)" args =>+                 String -> ArgsHMap "_backward_sqrt(symbol)" args -> IO SymbolHandle+_backward_sqrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sqrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "rsqrt(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++rsqrt ::+      forall args . Fullfilled "rsqrt(symbol)" args =>+        String -> ArgsHMap "rsqrt(symbol)" args -> IO SymbolHandle+rsqrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rsqrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_rsqrt(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_rsqrt ::+                forall args . Fullfilled "_backward_rsqrt(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_rsqrt(symbol)" args -> IO SymbolHandle+_backward_rsqrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rsqrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "cbrt(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++cbrt ::+     forall args . Fullfilled "cbrt(symbol)" args =>+       String -> ArgsHMap "cbrt(symbol)" args -> IO SymbolHandle+cbrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cbrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_cbrt(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_cbrt ::+               forall args . Fullfilled "_backward_cbrt(symbol)" args =>+                 String -> ArgsHMap "_backward_cbrt(symbol)" args -> IO SymbolHandle+_backward_cbrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cbrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "rcbrt(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++rcbrt ::+      forall args . Fullfilled "rcbrt(symbol)" args =>+        String -> ArgsHMap "rcbrt(symbol)" args -> IO SymbolHandle+rcbrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rcbrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_rcbrt(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_rcbrt ::+                forall args . Fullfilled "_backward_rcbrt(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_rcbrt(symbol)" args -> IO SymbolHandle+_backward_rcbrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rcbrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "exp(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++exp ::+    forall args . Fullfilled "exp(symbol)" args =>+      String -> ArgsHMap "exp(symbol)" args -> IO SymbolHandle+exp name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "exp"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "log(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++log ::+    forall args . Fullfilled "log(symbol)" args =>+      String -> ArgsHMap "log(symbol)" args -> IO SymbolHandle+log name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "log10(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++log10 ::+      forall args . Fullfilled "log10(symbol)" args =>+        String -> ArgsHMap "log10(symbol)" args -> IO SymbolHandle+log10 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log10"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "log2(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++log2 ::+     forall args . Fullfilled "log2(symbol)" args =>+       String -> ArgsHMap "log2(symbol)" args -> IO SymbolHandle+log2 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log2"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_log(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_log ::+              forall args . Fullfilled "_backward_log(symbol)" args =>+                String -> ArgsHMap "_backward_log(symbol)" args -> IO SymbolHandle+_backward_log name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_log10(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_log10 ::+                forall args . Fullfilled "_backward_log10(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_log10(symbol)" args -> IO SymbolHandle+_backward_log10 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log10"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_log2(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_log2 ::+               forall args . Fullfilled "_backward_log2(symbol)" args =>+                 String -> ArgsHMap "_backward_log2(symbol)" args -> IO SymbolHandle+_backward_log2 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log2"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "log1p(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++log1p ::+      forall args . Fullfilled "log1p(symbol)" args =>+        String -> ArgsHMap "log1p(symbol)" args -> IO SymbolHandle+log1p name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log1p"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_log1p(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_log1p ::+                forall args . Fullfilled "_backward_log1p(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_log1p(symbol)" args -> IO SymbolHandle+_backward_log1p name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log1p"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "expm1(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++expm1 ::+      forall args . Fullfilled "expm1(symbol)" args =>+        String -> ArgsHMap "expm1(symbol)" args -> IO SymbolHandle+expm1 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "expm1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_expm1(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_expm1 ::+                forall args . Fullfilled "_backward_expm1(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_expm1(symbol)" args -> IO SymbolHandle+_backward_expm1 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_expm1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "gamma(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++gamma ::+      forall args . Fullfilled "gamma(symbol)" args =>+        String -> ArgsHMap "gamma(symbol)" args -> IO SymbolHandle+gamma name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gamma"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_gamma(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_gamma ::+                forall args . Fullfilled "_backward_gamma(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_gamma(symbol)" args -> IO SymbolHandle+_backward_gamma name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_gamma"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "gammaln(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++gammaln ::+        forall args . Fullfilled "gammaln(symbol)" args =>+          String -> ArgsHMap "gammaln(symbol)" args -> IO SymbolHandle+gammaln name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gammaln"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_gammaln(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_gammaln ::+                  forall args . Fullfilled "_backward_gammaln(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_gammaln(symbol)" args -> IO SymbolHandle+_backward_gammaln name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_gammaln"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sum(symbol)" =+     '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++sum ::+    forall args . Fullfilled "sum(symbol)" args =>+      String -> ArgsHMap "sum(symbol)" args -> IO SymbolHandle+sum name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sum(symbol)" = '[]++_backward_sum ::+              forall args . Fullfilled "_backward_sum(symbol)" args =>+                String -> ArgsHMap "_backward_sum(symbol)" args -> IO SymbolHandle+_backward_sum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "mean(symbol)" =+     '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++mean ::+     forall args . Fullfilled "mean(symbol)" args =>+       String -> ArgsHMap "mean(symbol)" args -> IO SymbolHandle+mean name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mean"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_mean(symbol)" = '[]++_backward_mean ::+               forall args . Fullfilled "_backward_mean(symbol)" args =>+                 String -> ArgsHMap "_backward_mean(symbol)" args -> IO SymbolHandle+_backward_mean name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mean"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "prod(symbol)" =+     '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++prod ::+     forall args . Fullfilled "prod(symbol)" args =>+       String -> ArgsHMap "prod(symbol)" args -> IO SymbolHandle+prod name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "prod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_prod(symbol)" = '[]++_backward_prod ::+               forall args . Fullfilled "_backward_prod(symbol)" args =>+                 String -> ArgsHMap "_backward_prod(symbol)" args -> IO SymbolHandle+_backward_prod name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_prod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "nansum(symbol)" =+     '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++nansum ::+       forall args . Fullfilled "nansum(symbol)" args =>+         String -> ArgsHMap "nansum(symbol)" args -> IO SymbolHandle+nansum name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "nansum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_nansum(symbol)" = '[]++_backward_nansum ::+                 forall args . Fullfilled "_backward_nansum(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_nansum(symbol)" args -> IO SymbolHandle+_backward_nansum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_nansum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "nanprod(symbol)" =+     '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++nanprod ::+        forall args . Fullfilled "nanprod(symbol)" args =>+          String -> ArgsHMap "nanprod(symbol)" args -> IO SymbolHandle+nanprod name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "nanprod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_nanprod(symbol)" = '[]++_backward_nanprod ::+                  forall args . Fullfilled "_backward_nanprod(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_nanprod(symbol)" args -> IO SymbolHandle+_backward_nanprod name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_nanprod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "max(symbol)" =+     '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++max ::+    forall args . Fullfilled "max(symbol)" args =>+      String -> ArgsHMap "max(symbol)" args -> IO SymbolHandle+max name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "max"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_max(symbol)" = '[]++_backward_max ::+              forall args . Fullfilled "_backward_max(symbol)" args =>+                String -> ArgsHMap "_backward_max(symbol)" args -> IO SymbolHandle+_backward_max name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_max"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "min(symbol)" =+     '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++min ::+    forall args . Fullfilled "min(symbol)" args =>+      String -> ArgsHMap "min(symbol)" args -> IO SymbolHandle+min name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "min"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_min(symbol)" = '[]++_backward_min ::+              forall args . Fullfilled "_backward_min(symbol)" args =>+                String -> ArgsHMap "_backward_min(symbol)" args -> IO SymbolHandle+_backward_min name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_min"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_axis(symbol)" =+     '[ '("axis", AttrOpt [Int]), '("size", AttrOpt [Int]),+        '("data", AttrOpt SymbolHandle)]++broadcast_axis ::+               forall args . Fullfilled "broadcast_axis(symbol)" args =>+                 String -> ArgsHMap "broadcast_axis(symbol)" args -> IO SymbolHandle+broadcast_axis name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),+               ("size",) . showValue <$> (args !? #size :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_axis"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_to(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]++broadcast_to ::+             forall args . Fullfilled "broadcast_to(symbol)" args =>+               String -> ArgsHMap "broadcast_to(symbol)" args -> IO SymbolHandle+broadcast_to name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_to"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_broadcast_backward(symbol)" = '[]++_broadcast_backward ::+                    forall args . Fullfilled "_broadcast_backward(symbol)" args =>+                      String ->+                        ArgsHMap "_broadcast_backward(symbol)" args -> IO SymbolHandle+_broadcast_backward name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_broadcast_backward"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "norm(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++norm ::+     forall args . Fullfilled "norm(symbol)" args =>+       String -> ArgsHMap "norm(symbol)" args -> IO SymbolHandle+norm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "norm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "elemwise_add(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++elemwise_add ::+             forall args . Fullfilled "elemwise_add(symbol)" args =>+               String -> ArgsHMap "elemwise_add(symbol)" args -> IO SymbolHandle+elemwise_add name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_add"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_grad_add(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_grad_add ::+          forall args . Fullfilled "_grad_add(symbol)" args =>+            String -> ArgsHMap "_grad_add(symbol)" args -> IO SymbolHandle+_grad_add name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_grad_add"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_add(symbol)" = '[]++_backward_add ::+              forall args . Fullfilled "_backward_add(symbol)" args =>+                String -> ArgsHMap "_backward_add(symbol)" args -> IO SymbolHandle+_backward_add name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_add"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "elemwise_sub(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++elemwise_sub ::+             forall args . Fullfilled "elemwise_sub(symbol)" args =>+               String -> ArgsHMap "elemwise_sub(symbol)" args -> IO SymbolHandle+elemwise_sub name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_sub"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sub(symbol)" = '[]++_backward_sub ::+              forall args . Fullfilled "_backward_sub(symbol)" args =>+                String -> ArgsHMap "_backward_sub(symbol)" args -> IO SymbolHandle+_backward_sub name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sub"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "elemwise_mul(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++elemwise_mul ::+             forall args . Fullfilled "elemwise_mul(symbol)" args =>+               String -> ArgsHMap "elemwise_mul(symbol)" args -> IO SymbolHandle+elemwise_mul name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_mul"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_mul(symbol)" = '[]++_backward_mul ::+              forall args . Fullfilled "_backward_mul(symbol)" args =>+                String -> ArgsHMap "_backward_mul(symbol)" args -> IO SymbolHandle+_backward_mul name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mul"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "elemwise_div(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++elemwise_div ::+             forall args . Fullfilled "elemwise_div(symbol)" args =>+               String -> ArgsHMap "elemwise_div(symbol)" args -> IO SymbolHandle+elemwise_div name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_div"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_div(symbol)" = '[]++_backward_div ::+              forall args . Fullfilled "_backward_div(symbol)" args =>+                String -> ArgsHMap "_backward_div(symbol)" args -> IO SymbolHandle+_backward_div name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_div"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_mod(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_mod ::+     forall args . Fullfilled "_mod(symbol)" args =>+       String -> ArgsHMap "_mod(symbol)" args -> IO SymbolHandle+_mod name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_mod(symbol)" = '[]++_backward_mod ::+              forall args . Fullfilled "_backward_mod(symbol)" args =>+                String -> ArgsHMap "_backward_mod(symbol)" args -> IO SymbolHandle+_backward_mod name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_plus_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_plus_scalar ::+             forall args . Fullfilled "_plus_scalar(symbol)" args =>+               String -> ArgsHMap "_plus_scalar(symbol)" args -> IO SymbolHandle+_plus_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_plus_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_minus_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_minus_scalar ::+              forall args . Fullfilled "_minus_scalar(symbol)" args =>+                String -> ArgsHMap "_minus_scalar(symbol)" args -> IO SymbolHandle+_minus_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minus_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_rminus_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_rminus_scalar ::+               forall args . Fullfilled "_rminus_scalar(symbol)" args =>+                 String -> ArgsHMap "_rminus_scalar(symbol)" args -> IO SymbolHandle+_rminus_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rminus_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_mul_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_mul_scalar ::+            forall args . Fullfilled "_mul_scalar(symbol)" args =>+              String -> ArgsHMap "_mul_scalar(symbol)" args -> IO SymbolHandle+_mul_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mul_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_mul_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_backward_mul_scalar ::+                     forall args . Fullfilled "_backward_mul_scalar(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_mul_scalar(symbol)" args -> IO SymbolHandle+_backward_mul_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mul_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_div_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_div_scalar ::+            forall args . Fullfilled "_div_scalar(symbol)" args =>+              String -> ArgsHMap "_div_scalar(symbol)" args -> IO SymbolHandle+_div_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_div_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_div_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_backward_div_scalar ::+                     forall args . Fullfilled "_backward_div_scalar(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_div_scalar(symbol)" args -> IO SymbolHandle+_backward_div_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_div_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_rdiv_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_rdiv_scalar ::+             forall args . Fullfilled "_rdiv_scalar(symbol)" args =>+               String -> ArgsHMap "_rdiv_scalar(symbol)" args -> IO SymbolHandle+_rdiv_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rdiv_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_rdiv_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_rdiv_scalar ::+                      forall args . Fullfilled "_backward_rdiv_scalar(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_rdiv_scalar(symbol)" args -> IO SymbolHandle+_backward_rdiv_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rdiv_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_mod_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_mod_scalar ::+            forall args . Fullfilled "_mod_scalar(symbol)" args =>+              String -> ArgsHMap "_mod_scalar(symbol)" args -> IO SymbolHandle+_mod_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mod_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_mod_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_mod_scalar ::+                     forall args . Fullfilled "_backward_mod_scalar(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_mod_scalar(symbol)" args -> IO SymbolHandle+_backward_mod_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mod_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_rmod_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_rmod_scalar ::+             forall args . Fullfilled "_rmod_scalar(symbol)" args =>+               String -> ArgsHMap "_rmod_scalar(symbol)" args -> IO SymbolHandle+_rmod_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rmod_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_rmod_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_rmod_scalar ::+                      forall args . Fullfilled "_backward_rmod_scalar(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_rmod_scalar(symbol)" args -> IO SymbolHandle+_backward_rmod_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rmod_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_scatter_elemwise_div(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_scatter_elemwise_div ::+                      forall args . Fullfilled "_scatter_elemwise_div(symbol)" args =>+                        String ->+                          ArgsHMap "_scatter_elemwise_div(symbol)" args -> IO SymbolHandle+_scatter_elemwise_div name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_elemwise_div"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_scatter_plus_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_scatter_plus_scalar ::+                     forall args . Fullfilled "_scatter_plus_scalar(symbol)" args =>+                       String ->+                         ArgsHMap "_scatter_plus_scalar(symbol)" args -> IO SymbolHandle+_scatter_plus_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_plus_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_scatter_minus_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_scatter_minus_scalar ::+                      forall args . Fullfilled "_scatter_minus_scalar(symbol)" args =>+                        String ->+                          ArgsHMap "_scatter_minus_scalar(symbol)" args -> IO SymbolHandle+_scatter_minus_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_minus_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Embedding(symbol)" =+     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),+        '("dtype",+          AttrOpt+            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),+        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle)]++_Embedding ::+           forall args . Fullfilled "_Embedding(symbol)" args =>+             String -> ArgsHMap "_Embedding(symbol)" args -> IO SymbolHandle+_Embedding name args+  = let scalarArgs+          = catMaybes+              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Embedding"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_SparseEmbedding(symbol)" =+     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),+        '("dtype",+          AttrOpt+            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),+        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle)]++_contrib_SparseEmbedding ::+                         forall args . Fullfilled "_contrib_SparseEmbedding(symbol)" args =>+                           String ->+                             ArgsHMap "_contrib_SparseEmbedding(symbol)" args -> IO SymbolHandle+_contrib_SparseEmbedding name args+  = let scalarArgs+          = catMaybes+              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_SparseEmbedding"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Embedding(symbol)" = '[]++_backward_Embedding ::+                    forall args . Fullfilled "_backward_Embedding(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_Embedding(symbol)" args -> IO SymbolHandle+_backward_Embedding name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Embedding"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SparseEmbedding(symbol)" =+     '[]++_backward_SparseEmbedding ::+                          forall args .+                            Fullfilled "_backward_SparseEmbedding(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_SparseEmbedding(symbol)" args ->+                                IO SymbolHandle+_backward_SparseEmbedding name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SparseEmbedding"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "take(symbol)" =+     '[ '("axis", AttrOpt Int),+        '("mode", AttrOpt (EnumType '["clip", "raise", "wrap"])),+        '("a", AttrOpt SymbolHandle), '("indices", AttrOpt SymbolHandle)]++take ::+     forall args . Fullfilled "take(symbol)" args =>+       String -> ArgsHMap "take(symbol)" args -> IO SymbolHandle+take name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("a",) <$> (args !? #a :: Maybe SymbolHandle),+               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "take"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_take(symbol)" = '[]++_backward_take ::+               forall args . Fullfilled "_backward_take(symbol)" args =>+                 String -> ArgsHMap "_backward_take(symbol)" args -> IO SymbolHandle+_backward_take name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_take"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "batch_take(symbol)" =+     '[ '("a", AttrOpt SymbolHandle),+        '("indices", AttrOpt SymbolHandle)]++batch_take ::+           forall args . Fullfilled "batch_take(symbol)" args =>+             String -> ArgsHMap "batch_take(symbol)" args -> IO SymbolHandle+batch_take name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("a",) <$> (args !? #a :: Maybe SymbolHandle),+               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "batch_take"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "one_hot(symbol)" =+     '[ '("depth", AttrReq Int), '("on_value", AttrOpt Double),+        '("off_value", AttrOpt Double),+        '("dtype",+          AttrOpt+            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),+        '("indices", AttrOpt SymbolHandle)]++one_hot ::+        forall args . Fullfilled "one_hot(symbol)" args =>+          String -> ArgsHMap "one_hot(symbol)" args -> IO SymbolHandle+one_hot name args+  = let scalarArgs+          = catMaybes+              [("depth",) . showValue <$> (args !? #depth :: Maybe Int),+               ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double),+               ("off_value",) . showValue <$>+                 (args !? #off_value :: Maybe Double),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "one_hot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "gather_nd(symbol)" =+     '[ '("data", AttrOpt SymbolHandle),+        '("indices", AttrOpt SymbolHandle)]++gather_nd ::+          forall args . Fullfilled "gather_nd(symbol)" args =>+            String -> ArgsHMap "gather_nd(symbol)" args -> IO SymbolHandle+gather_nd name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gather_nd"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "scatter_nd(symbol)" =+     '[ '("shape", AttrReq [Int]), '("data", AttrOpt SymbolHandle),+        '("indices", AttrOpt SymbolHandle)]++scatter_nd ::+           forall args . Fullfilled "scatter_nd(symbol)" args =>+             String -> ArgsHMap "scatter_nd(symbol)" args -> IO SymbolHandle+scatter_nd name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "scatter_nd"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_scatter_set_nd(symbol)" =+     '[ '("shape", AttrReq [Int]), '("data", AttrOpt SymbolHandle),+        '("indices", AttrOpt SymbolHandle)]++_scatter_set_nd ::+                forall args . Fullfilled "_scatter_set_nd(symbol)" args =>+                  String ->+                    ArgsHMap "_scatter_set_nd(symbol)" args -> IO SymbolHandle+_scatter_set_nd name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_set_nd"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_equal ::+                forall args . Fullfilled "broadcast_equal(symbol)" args =>+                  String ->+                    ArgsHMap "broadcast_equal(symbol)" args -> IO SymbolHandle+broadcast_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_not_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_not_equal ::+                    forall args . Fullfilled "broadcast_not_equal(symbol)" args =>+                      String ->+                        ArgsHMap "broadcast_not_equal(symbol)" args -> IO SymbolHandle+broadcast_not_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_not_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_greater(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_greater ::+                  forall args . Fullfilled "broadcast_greater(symbol)" args =>+                    String ->+                      ArgsHMap "broadcast_greater(symbol)" args -> IO SymbolHandle+broadcast_greater name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_greater"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_greater_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_greater_equal ::+                        forall args . Fullfilled "broadcast_greater_equal(symbol)" args =>+                          String ->+                            ArgsHMap "broadcast_greater_equal(symbol)" args -> IO SymbolHandle+broadcast_greater_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_greater_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_lesser(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_lesser ::+                 forall args . Fullfilled "broadcast_lesser(symbol)" args =>+                   String ->+                     ArgsHMap "broadcast_lesser(symbol)" args -> IO SymbolHandle+broadcast_lesser name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_lesser"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_lesser_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_lesser_equal ::+                       forall args . Fullfilled "broadcast_lesser_equal(symbol)" args =>+                         String ->+                           ArgsHMap "broadcast_lesser_equal(symbol)" args -> IO SymbolHandle+broadcast_lesser_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_lesser_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "argmax(symbol)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle)]++argmax ::+       forall args . Fullfilled "argmax(symbol)" args =>+         String -> ArgsHMap "argmax(symbol)" args -> IO SymbolHandle+argmax name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmax"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "argmin(symbol)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle)]++argmin ::+       forall args . Fullfilled "argmin(symbol)" args =>+         String -> ArgsHMap "argmin(symbol)" args -> IO SymbolHandle+argmin name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmin"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "argmax_channel(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++argmax_channel ::+               forall args . Fullfilled "argmax_channel(symbol)" args =>+                 String -> ArgsHMap "argmax_channel(symbol)" args -> IO SymbolHandle+argmax_channel name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmax_channel"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "pick(symbol)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle), '("index", AttrOpt SymbolHandle)]++pick ::+     forall args . Fullfilled "pick(symbol)" args =>+       String -> ArgsHMap "pick(symbol)" args -> IO SymbolHandle+pick name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("index",) <$> (args !? #index :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "pick"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_pick(symbol)" = '[]++_backward_pick ::+               forall args . Fullfilled "_backward_pick(symbol)" args =>+                 String -> ArgsHMap "_backward_pick(symbol)" args -> IO SymbolHandle+_backward_pick name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_pick"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sparse_retain(symbol)" =+     '[ '("data", AttrOpt SymbolHandle),+        '("indices", AttrOpt SymbolHandle)]++_sparse_retain ::+               forall args . Fullfilled "_sparse_retain(symbol)" args =>+                 String -> ArgsHMap "_sparse_retain(symbol)" args -> IO SymbolHandle+_sparse_retain name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sparse_retain"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sparse_retain(symbol)" = '[]++_backward_sparse_retain ::+                        forall args . Fullfilled "_backward_sparse_retain(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_sparse_retain(symbol)" args -> IO SymbolHandle+_backward_sparse_retain name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sparse_retain"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_where(symbol)" =+     '[ '("condition", AttrOpt SymbolHandle),+        '("x", AttrOpt SymbolHandle), '("y", AttrOpt SymbolHandle)]++_where ::+       forall args . Fullfilled "_where(symbol)" args =>+         String -> ArgsHMap "_where(symbol)" args -> IO SymbolHandle+_where name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("condition",) <$> (args !? #condition :: Maybe SymbolHandle),+               ("x",) <$> (args !? #x :: Maybe SymbolHandle),+               ("y",) <$> (args !? #y :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "where"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_where(symbol)" = '[]++_backward_where ::+                forall args . Fullfilled "_backward_where(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_where(symbol)" args -> IO SymbolHandle+_backward_where name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_where"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_maximum_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_maximum_scalar ::+                forall args . Fullfilled "_maximum_scalar(symbol)" args =>+                  String ->+                    ArgsHMap "_maximum_scalar(symbol)" args -> IO SymbolHandle+_maximum_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_maximum_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_maximum_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_maximum_scalar ::+                         forall args . Fullfilled "_backward_maximum_scalar(symbol)" args =>+                           String ->+                             ArgsHMap "_backward_maximum_scalar(symbol)" args -> IO SymbolHandle+_backward_maximum_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_maximum_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_minimum_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_minimum_scalar ::+                forall args . Fullfilled "_minimum_scalar(symbol)" args =>+                  String ->+                    ArgsHMap "_minimum_scalar(symbol)" args -> IO SymbolHandle+_minimum_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minimum_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_minimum_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_minimum_scalar ::+                         forall args . Fullfilled "_backward_minimum_scalar(symbol)" args =>+                           String ->+                             ArgsHMap "_backward_minimum_scalar(symbol)" args -> IO SymbolHandle+_backward_minimum_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_minimum_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_power_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_power_scalar ::+              forall args . Fullfilled "_power_scalar(symbol)" args =>+                String -> ArgsHMap "_power_scalar(symbol)" args -> IO SymbolHandle+_power_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_power_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_power_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_power_scalar ::+                       forall args . Fullfilled "_backward_power_scalar(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_power_scalar(symbol)" args -> IO SymbolHandle+_backward_power_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_power_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_rpower_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_rpower_scalar ::+               forall args . Fullfilled "_rpower_scalar(symbol)" args =>+                 String -> ArgsHMap "_rpower_scalar(symbol)" args -> IO SymbolHandle+_rpower_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rpower_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_rpower_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_rpower_scalar ::+                        forall args . Fullfilled "_backward_rpower_scalar(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_rpower_scalar(symbol)" args -> IO SymbolHandle+_backward_rpower_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rpower_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_hypot_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_hypot_scalar ::+              forall args . Fullfilled "_hypot_scalar(symbol)" args =>+                String -> ArgsHMap "_hypot_scalar(symbol)" args -> IO SymbolHandle+_hypot_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_hypot_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_hypot_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_hypot_scalar ::+                       forall args . Fullfilled "_backward_hypot_scalar(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_hypot_scalar(symbol)" args -> IO SymbolHandle+_backward_hypot_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_hypot_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "smooth_l1(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++smooth_l1 ::+          forall args . Fullfilled "smooth_l1(symbol)" args =>+            String -> ArgsHMap "smooth_l1(symbol)" args -> IO SymbolHandle+smooth_l1 name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "smooth_l1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_smooth_l1(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_smooth_l1 ::+                    forall args . Fullfilled "_backward_smooth_l1(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_smooth_l1(symbol)" args -> IO SymbolHandle+_backward_smooth_l1 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_smooth_l1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "topk(symbol)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("k", AttrOpt Int),+        '("ret_typ",+          AttrOpt (EnumType '["both", "indices", "mask", "value"])),+        '("is_ascend", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++topk ::+     forall args . Fullfilled "topk(symbol)" args =>+       String -> ArgsHMap "topk(symbol)" args -> IO SymbolHandle+topk name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("ret_typ",) . showValue <$>+                 (args !? #ret_typ ::+                    Maybe (EnumType '["both", "indices", "mask", "value"])),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "topk"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_topk(symbol)" = '[]++_backward_topk ::+               forall args . Fullfilled "_backward_topk(symbol)" args =>+                 String -> ArgsHMap "_backward_topk(symbol)" args -> IO SymbolHandle+_backward_topk name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_topk"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sort(symbol)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle)]++sort ::+     forall args . Fullfilled "sort(symbol)" args =>+       String -> ArgsHMap "sort(symbol)" args -> IO SymbolHandle+sort name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sort"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "argsort(symbol)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle)]++argsort ::+        forall args . Fullfilled "argsort(symbol)" args =>+          String -> ArgsHMap "argsort(symbol)" args -> IO SymbolHandle+argsort name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argsort"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Reshape(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("reverse", AttrOpt Bool),+        '("target_shape", AttrOpt [Int]), '("keep_highest", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle)]++_Reshape ::+         forall args . Fullfilled "_Reshape(symbol)" args =>+           String -> ArgsHMap "_Reshape(symbol)" args -> IO SymbolHandle+_Reshape name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("keep_highest",) . showValue <$>+                 (args !? #keep_highest :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Reshape"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Flatten(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++_Flatten ::+         forall args . Fullfilled "_Flatten(symbol)" args =>+           String -> ArgsHMap "_Flatten(symbol)" args -> IO SymbolHandle+_Flatten name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Flatten"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "transpose(symbol)" =+     '[ '("axes", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]++transpose ::+          forall args . Fullfilled "transpose(symbol)" args =>+            String -> ArgsHMap "transpose(symbol)" args -> IO SymbolHandle+transpose name args+  = let scalarArgs+          = catMaybes+              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "transpose"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "expand_dims(symbol)" =+     '[ '("axis", AttrReq Int), '("data", AttrOpt SymbolHandle)]++expand_dims ::+            forall args . Fullfilled "expand_dims(symbol)" args =>+              String -> ArgsHMap "expand_dims(symbol)" args -> IO SymbolHandle+expand_dims name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "expand_dims"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "slice(symbol)" =+     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),+        '("step", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]++slice ::+      forall args . Fullfilled "slice(symbol)" args =>+        String -> ArgsHMap "slice(symbol)" args -> IO SymbolHandle+slice name args+  = let scalarArgs+          = catMaybes+              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "slice"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_slice(symbol)" = '[]++_backward_slice ::+                forall args . Fullfilled "_backward_slice(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_slice(symbol)" args -> IO SymbolHandle+_backward_slice name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_slice"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_slice_assign(symbol)" =+     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),+        '("step", AttrOpt [Int]), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_slice_assign ::+              forall args . Fullfilled "_slice_assign(symbol)" args =>+                String -> ArgsHMap "_slice_assign(symbol)" args -> IO SymbolHandle+_slice_assign name args+  = let scalarArgs+          = catMaybes+              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_slice_assign"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_slice_assign_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("begin", AttrReq [Int]),+        '("end", AttrReq [Int]), '("step", AttrOpt [Int]),+        '("data", AttrOpt SymbolHandle)]++_slice_assign_scalar ::+                     forall args . Fullfilled "_slice_assign_scalar(symbol)" args =>+                       String ->+                         ArgsHMap "_slice_assign_scalar(symbol)" args -> IO SymbolHandle+_slice_assign_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float),+               ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_slice_assign_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "slice_axis(symbol)" =+     '[ '("axis", AttrReq Int), '("begin", AttrReq Int),+        '("end", AttrReq (Maybe Int)), '("data", AttrOpt SymbolHandle)]++slice_axis ::+           forall args . Fullfilled "slice_axis(symbol)" args =>+             String -> ArgsHMap "slice_axis(symbol)" args -> IO SymbolHandle+slice_axis name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("begin",) . showValue <$> (args !? #begin :: Maybe Int),+               ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "slice_axis"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_slice_axis(symbol)" = '[]++_backward_slice_axis ::+                     forall args . Fullfilled "_backward_slice_axis(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_slice_axis(symbol)" args -> IO SymbolHandle+_backward_slice_axis name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_slice_axis"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "clip(symbol)" =+     '[ '("a_min", AttrReq Float), '("a_max", AttrReq Float),+        '("data", AttrOpt SymbolHandle)]++clip ::+     forall args . Fullfilled "clip(symbol)" args =>+       String -> ArgsHMap "clip(symbol)" args -> IO SymbolHandle+clip name args+  = let scalarArgs+          = catMaybes+              [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float),+               ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "clip"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_clip(symbol)" = '[]++_backward_clip ::+               forall args . Fullfilled "_backward_clip(symbol)" args =>+                 String -> ArgsHMap "_backward_clip(symbol)" args -> IO SymbolHandle+_backward_clip name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_clip"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "repeat(symbol)" =+     '[ '("repeats", AttrReq Int), '("axis", AttrOpt (Maybe Int)),+        '("data", AttrOpt SymbolHandle)]++repeat ::+       forall args . Fullfilled "repeat(symbol)" args =>+         String -> ArgsHMap "repeat(symbol)" args -> IO SymbolHandle+repeat name args+  = let scalarArgs+          = catMaybes+              [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int),+               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "repeat"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_repeat(symbol)" = '[]++_backward_repeat ::+                 forall args . Fullfilled "_backward_repeat(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_repeat(symbol)" args -> IO SymbolHandle+_backward_repeat name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_repeat"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "tile(symbol)" =+     '[ '("reps", AttrReq [Int]), '("data", AttrOpt SymbolHandle)]++tile ::+     forall args . Fullfilled "tile(symbol)" args =>+       String -> ArgsHMap "tile(symbol)" args -> IO SymbolHandle+tile name args+  = let scalarArgs+          = catMaybes+              [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tile"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_tile(symbol)" = '[]++_backward_tile ::+               forall args . Fullfilled "_backward_tile(symbol)" args =>+                 String -> ArgsHMap "_backward_tile(symbol)" args -> IO SymbolHandle+_backward_tile name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tile"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "reverse(symbol)" =+     '[ '("axis", AttrReq [Int]), '("data", AttrOpt SymbolHandle)]++reverse ::+        forall args . Fullfilled "reverse(symbol)" args =>+          String -> ArgsHMap "reverse(symbol)" args -> IO SymbolHandle+reverse name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reverse"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_reverse(symbol)" = '[]++_backward_reverse ::+                  forall args . Fullfilled "_backward_reverse(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_reverse(symbol)" args -> IO SymbolHandle+_backward_reverse name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_reverse"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "stack(symbol)" =+     '[ '("axis", AttrOpt Int), '("num_args", AttrReq Int),+        '("data", AttrOpt [SymbolHandle])]++stack ::+      forall args . Fullfilled "stack(symbol)" args =>+        String -> ArgsHMap "stack(symbol)" args -> IO SymbolHandle+stack name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "stack"+         sym <- if hasKey args #num_args then+                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals+                  else+                  mxSymbolCreateAtomicSymbol (fromOpHandle op)+                    ("num_args" : scalarkeys)+                    (showValue (length array) : scalarvals)+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_backward_stack(symbol)" = '[]++_backward_stack ::+                forall args . Fullfilled "_backward_stack(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_stack(symbol)" args -> IO SymbolHandle+_backward_stack name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_stack"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "dot(symbol)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++dot ::+    forall args . Fullfilled "dot(symbol)" args =>+      String -> ArgsHMap "dot(symbol)" args -> IO SymbolHandle+dot name args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "dot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_dot(symbol)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool)]++_backward_dot ::+              forall args . Fullfilled "_backward_dot(symbol)" args =>+                String -> ArgsHMap "_backward_dot(symbol)" args -> IO SymbolHandle+_backward_dot name args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_dot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "batch_dot(symbol)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++batch_dot ::+          forall args . Fullfilled "batch_dot(symbol)" args =>+            String -> ArgsHMap "batch_dot(symbol)" args -> IO SymbolHandle+batch_dot name args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "batch_dot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_batch_dot(symbol)" = '[]++_backward_batch_dot ::+                    forall args . Fullfilled "_backward_batch_dot(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_batch_dot(symbol)" args -> IO SymbolHandle+_backward_batch_dot name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_batch_dot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sin(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++sin ::+    forall args . Fullfilled "sin(symbol)" args =>+      String -> ArgsHMap "sin(symbol)" args -> IO SymbolHandle+sin name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sin"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sin(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_sin ::+              forall args . Fullfilled "_backward_sin(symbol)" args =>+                String -> ArgsHMap "_backward_sin(symbol)" args -> IO SymbolHandle+_backward_sin name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sin"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "cos(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++cos ::+    forall args . Fullfilled "cos(symbol)" args =>+      String -> ArgsHMap "cos(symbol)" args -> IO SymbolHandle+cos name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cos"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_cos(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_cos ::+              forall args . Fullfilled "_backward_cos(symbol)" args =>+                String -> ArgsHMap "_backward_cos(symbol)" args -> IO SymbolHandle+_backward_cos name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cos"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "tan(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++tan ::+    forall args . Fullfilled "tan(symbol)" args =>+      String -> ArgsHMap "tan(symbol)" args -> IO SymbolHandle+tan name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tan"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_tan(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_tan ::+              forall args . Fullfilled "_backward_tan(symbol)" args =>+                String -> ArgsHMap "_backward_tan(symbol)" args -> IO SymbolHandle+_backward_tan name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tan"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "arcsin(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++arcsin ::+       forall args . Fullfilled "arcsin(symbol)" args =>+         String -> ArgsHMap "arcsin(symbol)" args -> IO SymbolHandle+arcsin name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arcsin"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_arcsin(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_arcsin ::+                 forall args . Fullfilled "_backward_arcsin(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_arcsin(symbol)" args -> IO SymbolHandle+_backward_arcsin name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arcsin"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "arccos(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++arccos ::+       forall args . Fullfilled "arccos(symbol)" args =>+         String -> ArgsHMap "arccos(symbol)" args -> IO SymbolHandle+arccos name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arccos"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_arccos(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_arccos ::+                 forall args . Fullfilled "_backward_arccos(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_arccos(symbol)" args -> IO SymbolHandle+_backward_arccos name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arccos"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "arctan(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++arctan ::+       forall args . Fullfilled "arctan(symbol)" args =>+         String -> ArgsHMap "arctan(symbol)" args -> IO SymbolHandle+arctan name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arctan"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_arctan(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_arctan ::+                 forall args . Fullfilled "_backward_arctan(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_arctan(symbol)" args -> IO SymbolHandle+_backward_arctan name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arctan"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "degrees(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++degrees ::+        forall args . Fullfilled "degrees(symbol)" args =>+          String -> ArgsHMap "degrees(symbol)" args -> IO SymbolHandle+degrees name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "degrees"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_degrees(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_degrees ::+                  forall args . Fullfilled "_backward_degrees(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_degrees(symbol)" args -> IO SymbolHandle+_backward_degrees name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_degrees"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "radians(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++radians ::+        forall args . Fullfilled "radians(symbol)" args =>+          String -> ArgsHMap "radians(symbol)" args -> IO SymbolHandle+radians name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "radians"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_radians(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_radians ::+                  forall args . Fullfilled "_backward_radians(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_radians(symbol)" args -> IO SymbolHandle+_backward_radians name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_radians"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sinh(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++sinh ::+     forall args . Fullfilled "sinh(symbol)" args =>+       String -> ArgsHMap "sinh(symbol)" args -> IO SymbolHandle+sinh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sinh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sinh(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_sinh ::+               forall args . Fullfilled "_backward_sinh(symbol)" args =>+                 String -> ArgsHMap "_backward_sinh(symbol)" args -> IO SymbolHandle+_backward_sinh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sinh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "cosh(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++cosh ::+     forall args . Fullfilled "cosh(symbol)" args =>+       String -> ArgsHMap "cosh(symbol)" args -> IO SymbolHandle+cosh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cosh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_cosh(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_cosh ::+               forall args . Fullfilled "_backward_cosh(symbol)" args =>+                 String -> ArgsHMap "_backward_cosh(symbol)" args -> IO SymbolHandle+_backward_cosh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cosh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "tanh(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++tanh ::+     forall args . Fullfilled "tanh(symbol)" args =>+       String -> ArgsHMap "tanh(symbol)" args -> IO SymbolHandle+tanh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tanh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_tanh(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_tanh ::+               forall args . Fullfilled "_backward_tanh(symbol)" args =>+                 String -> ArgsHMap "_backward_tanh(symbol)" args -> IO SymbolHandle+_backward_tanh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tanh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "arcsinh(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++arcsinh ::+        forall args . Fullfilled "arcsinh(symbol)" args =>+          String -> ArgsHMap "arcsinh(symbol)" args -> IO SymbolHandle+arcsinh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arcsinh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_arcsinh(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_arcsinh ::+                  forall args . Fullfilled "_backward_arcsinh(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_arcsinh(symbol)" args -> IO SymbolHandle+_backward_arcsinh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arcsinh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "arccosh(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++arccosh ::+        forall args . Fullfilled "arccosh(symbol)" args =>+          String -> ArgsHMap "arccosh(symbol)" args -> IO SymbolHandle+arccosh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arccosh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_arccosh(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_arccosh ::+                  forall args . Fullfilled "_backward_arccosh(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_arccosh(symbol)" args -> IO SymbolHandle+_backward_arccosh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arccosh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "arctanh(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++arctanh ::+        forall args . Fullfilled "arctanh(symbol)" args =>+          String -> ArgsHMap "arctanh(symbol)" args -> IO SymbolHandle+arctanh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arctanh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_arctanh(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_arctanh ::+                  forall args . Fullfilled "_backward_arctanh(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_arctanh(symbol)" args -> IO SymbolHandle+_backward_arctanh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arctanh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_dequantize(symbol)" =+     '[ '("out_type", AttrReq (EnumType '["float32"])),+        '("input", AttrOpt SymbolHandle),+        '("min_range", AttrOpt SymbolHandle),+        '("max_range", AttrOpt SymbolHandle)]++_contrib_dequantize ::+                    forall args . Fullfilled "_contrib_dequantize(symbol)" args =>+                      String ->+                        ArgsHMap "_contrib_dequantize(symbol)" args -> IO SymbolHandle+_contrib_dequantize name args+  = let scalarArgs+          = catMaybes+              [("out_type",) . showValue <$>+                 (args !? #out_type :: Maybe (EnumType '["float32"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("input",) <$> (args !? #input :: Maybe SymbolHandle),+               ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle),+               ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_dequantize"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_CTCLoss(symbol)" =+     '[ '("use_data_lengths", AttrOpt Bool),+        '("use_label_lengths", AttrOpt Bool),+        '("blank_label", AttrOpt (EnumType '["first", "last"])),+        '("data", AttrOpt SymbolHandle), '("label", AttrOpt SymbolHandle),+        '("data_lengths", AttrOpt SymbolHandle),+        '("label_lengths", AttrOpt SymbolHandle)]++_contrib_CTCLoss ::+                 forall args . Fullfilled "_contrib_CTCLoss(symbol)" args =>+                   String ->+                     ArgsHMap "_contrib_CTCLoss(symbol)" args -> IO SymbolHandle+_contrib_CTCLoss name args+  = let scalarArgs+          = catMaybes+              [("use_data_lengths",) . showValue <$>+                 (args !? #use_data_lengths :: Maybe Bool),+               ("use_label_lengths",) . showValue <$>+                 (args !? #use_label_lengths :: Maybe Bool),+               ("blank_label",) . showValue <$>+                 (args !? #blank_label :: Maybe (EnumType '["first", "last"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle),+               ("data_lengths",) <$>+                 (args !? #data_lengths :: Maybe SymbolHandle),+               ("label_lengths",) <$>+                 (args !? #label_lengths :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_CTCLoss"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_quantize(symbol)" =+     '[ '("out_type", AttrOpt (EnumType '["uint8"])),+        '("input", AttrOpt SymbolHandle),+        '("min_range", AttrOpt SymbolHandle),+        '("max_range", AttrOpt SymbolHandle)]++_contrib_quantize ::+                  forall args . Fullfilled "_contrib_quantize(symbol)" args =>+                    String ->+                      ArgsHMap "_contrib_quantize(symbol)" args -> IO SymbolHandle+_contrib_quantize name args+  = let scalarArgs+          = catMaybes+              [("out_type",) . showValue <$>+                 (args !? #out_type :: Maybe (EnumType '["uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("input",) <$> (args !? #input :: Maybe SymbolHandle),+               ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle),+               ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantize"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Custom(symbol)" =+     '[ '("op_type", AttrOpt String), '("data", AttrOpt [SymbolHandle])]++_Custom ::+        forall args .+          (Fullfilled "_Custom(symbol)" args,+           PopKey (ArgOf "_Custom(symbol)") args "data",+           Dump (PopResult (ArgOf "_Custom(symbol)") args "data")) =>+          String -> ArgsHMap "_Custom(symbol)" args -> IO SymbolHandle+_Custom name args+  = let scalarArgs = dump (pop args #data)+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "Custom"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_backward_Custom(symbol)" = '[]++_backward_Custom ::+                 forall args . Fullfilled "_backward_Custom(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_Custom(symbol)" args -> IO SymbolHandle+_backward_Custom name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Custom"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_multinomial(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("get_prob", AttrOpt Bool),+        '("dtype", AttrOpt (EnumType '["int32"])),+        '("data", AttrOpt SymbolHandle)]++_sample_multinomial ::+                    forall args . Fullfilled "_sample_multinomial(symbol)" args =>+                      String ->+                        ArgsHMap "_sample_multinomial(symbol)" args -> IO SymbolHandle+_sample_multinomial name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool),+               ("dtype",) . showValue <$>+                 (args !? #dtype :: Maybe (EnumType '["int32"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_multinomial"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sample_multinomial(symbol)"+     = '[]++_backward_sample_multinomial ::+                             forall args .+                               Fullfilled "_backward_sample_multinomial(symbol)" args =>+                               String ->+                                 ArgsHMap "_backward_sample_multinomial(symbol)" args ->+                                   IO SymbolHandle+_backward_sample_multinomial name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sample_multinomial"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_uniform(symbol)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("low", AttrOpt SymbolHandle), '("high", AttrOpt SymbolHandle)]++_sample_uniform ::+                forall args . Fullfilled "_sample_uniform(symbol)" args =>+                  String ->+                    ArgsHMap "_sample_uniform(symbol)" args -> IO SymbolHandle+_sample_uniform name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("low",) <$> (args !? #low :: Maybe SymbolHandle),+               ("high",) <$> (args !? #high :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_uniform"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_normal(symbol)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("mu", AttrOpt SymbolHandle), '("sigma", AttrOpt SymbolHandle)]++_sample_normal ::+               forall args . Fullfilled "_sample_normal(symbol)" args =>+                 String -> ArgsHMap "_sample_normal(symbol)" args -> IO SymbolHandle+_sample_normal name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("mu",) <$> (args !? #mu :: Maybe SymbolHandle),+               ("sigma",) <$> (args !? #sigma :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_normal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_gamma(symbol)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("alpha", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle)]++_sample_gamma ::+              forall args . Fullfilled "_sample_gamma(symbol)" args =>+                String -> ArgsHMap "_sample_gamma(symbol)" args -> IO SymbolHandle+_sample_gamma name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("alpha",) <$> (args !? #alpha :: Maybe SymbolHandle),+               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_gamma"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_exponential(symbol)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("lam", AttrOpt SymbolHandle)]++_sample_exponential ::+                    forall args . Fullfilled "_sample_exponential(symbol)" args =>+                      String ->+                        ArgsHMap "_sample_exponential(symbol)" args -> IO SymbolHandle+_sample_exponential name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("lam",) <$> (args !? #lam :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_exponential"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_poisson(symbol)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("lam", AttrOpt SymbolHandle)]++_sample_poisson ::+                forall args . Fullfilled "_sample_poisson(symbol)" args =>+                  String ->+                    ArgsHMap "_sample_poisson(symbol)" args -> IO SymbolHandle+_sample_poisson name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("lam",) <$> (args !? #lam :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_poisson"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_negative_binomial(symbol)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("k", AttrOpt SymbolHandle), '("p", AttrOpt SymbolHandle)]++_sample_negative_binomial ::+                          forall args .+                            Fullfilled "_sample_negative_binomial(symbol)" args =>+                            String ->+                              ArgsHMap "_sample_negative_binomial(symbol)" args ->+                                IO SymbolHandle+_sample_negative_binomial name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("k",) <$> (args !? #k :: Maybe SymbolHandle),+               ("p",) <$> (args !? #p :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_negative_binomial"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_sample_generalized_negative_binomial(symbol)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("mu", AttrOpt SymbolHandle), '("alpha", AttrOpt SymbolHandle)]++_sample_generalized_negative_binomial ::+                                      forall args .+                                        Fullfilled "_sample_generalized_negative_binomial(symbol)"+                                          args =>+                                        String ->+                                          ArgsHMap "_sample_generalized_negative_binomial(symbol)"+                                            args+                                            -> IO SymbolHandle+_sample_generalized_negative_binomial name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("mu",) <$> (args !? #mu :: Maybe SymbolHandle),+               ("alpha",) <$> (args !? #alpha :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_generalized_negative_binomial"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_uniform(symbol)" =+     '[ '("low", AttrOpt Float), '("high", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_uniform ::+                forall args . Fullfilled "_random_uniform(symbol)" args =>+                  String ->+                    ArgsHMap "_random_uniform(symbol)" args -> IO SymbolHandle+_random_uniform name args+  = let scalarArgs+          = catMaybes+              [("low",) . showValue <$> (args !? #low :: Maybe Float),+               ("high",) . showValue <$> (args !? #high :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_uniform"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_normal(symbol)" =+     '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_normal ::+               forall args . Fullfilled "_random_normal(symbol)" args =>+                 String -> ArgsHMap "_random_normal(symbol)" args -> IO SymbolHandle+_random_normal name args+  = let scalarArgs+          = catMaybes+              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),+               ("scale",) . showValue <$> (args !? #scale :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_normal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_gamma(symbol)" =+     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_gamma ::+              forall args . Fullfilled "_random_gamma(symbol)" args =>+                String -> ArgsHMap "_random_gamma(symbol)" args -> IO SymbolHandle+_random_gamma name args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_gamma"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_exponential(symbol)" =+     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),+        '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_exponential ::+                    forall args . Fullfilled "_random_exponential(symbol)" args =>+                      String ->+                        ArgsHMap "_random_exponential(symbol)" args -> IO SymbolHandle+_random_exponential name args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_exponential"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_poisson(symbol)" =+     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),+        '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_poisson ::+                forall args . Fullfilled "_random_poisson(symbol)" args =>+                  String ->+                    ArgsHMap "_random_poisson(symbol)" args -> IO SymbolHandle+_random_poisson name args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_poisson"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_negative_binomial(symbol)" =+     '[ '("k", AttrOpt Int), '("p", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_negative_binomial ::+                          forall args .+                            Fullfilled "_random_negative_binomial(symbol)" args =>+                            String ->+                              ArgsHMap "_random_negative_binomial(symbol)" args ->+                                IO SymbolHandle+_random_negative_binomial name args+  = let scalarArgs+          = catMaybes+              [("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_negative_binomial"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_random_generalized_negative_binomial(symbol)" =+     '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_generalized_negative_binomial ::+                                      forall args .+                                        Fullfilled "_random_generalized_negative_binomial(symbol)"+                                          args =>+                                        String ->+                                          ArgsHMap "_random_generalized_negative_binomial(symbol)"+                                            args+                                            -> IO SymbolHandle+_random_generalized_negative_binomial name args+  = let scalarArgs+          = catMaybes+              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_generalized_negative_binomial"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "softmax(symbol)" =+     '[ '("axis", AttrOpt Int), '("data", AttrOpt SymbolHandle)]++softmax ::+        forall args . Fullfilled "softmax(symbol)" args =>+          String -> ArgsHMap "softmax(symbol)" args -> IO SymbolHandle+softmax name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softmax"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_softmax(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_softmax ::+                  forall args . Fullfilled "_backward_softmax(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_softmax(symbol)" args -> IO SymbolHandle+_backward_softmax name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_softmax"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "log_softmax(symbol)" =+     '[ '("axis", AttrOpt Int), '("data", AttrOpt SymbolHandle)]++log_softmax ::+            forall args . Fullfilled "log_softmax(symbol)" args =>+              String -> ArgsHMap "log_softmax(symbol)" args -> IO SymbolHandle+log_softmax name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log_softmax"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_log_softmax(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_log_softmax ::+                      forall args . Fullfilled "_backward_log_softmax(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_log_softmax(symbol)" args -> IO SymbolHandle+_backward_log_softmax name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log_softmax"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_cvimread(symbol)" =+     '[ '("filename", AttrReq String), '("flag", AttrOpt Int),+        '("to_rgb", AttrOpt Bool)]++_cvimread ::+          forall args . Fullfilled "_cvimread(symbol)" args =>+            String -> ArgsHMap "_cvimread(symbol)" args -> IO SymbolHandle+_cvimread name args+  = let scalarArgs+          = catMaybes+              [("filename",) . showValue <$> (args !? #filename :: Maybe String),+               ("flag",) . showValue <$> (args !? #flag :: Maybe Int),+               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_cvimread"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_NoGradient(symbol)" = '[]++_NoGradient ::+            forall args . Fullfilled "_NoGradient(symbol)" args =>+              String -> ArgsHMap "_NoGradient(symbol)" args -> IO SymbolHandle+_NoGradient name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_NoGradient"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_CachedOp(symbol)" = '[]++_CachedOp ::+          forall args . Fullfilled "_CachedOp(symbol)" args =>+            String -> ArgsHMap "_CachedOp(symbol)" args -> IO SymbolHandle+_CachedOp name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_CachedOp"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_CachedOp(symbol)" = '[]++_backward_CachedOp ::+                   forall args . Fullfilled "_backward_CachedOp(symbol)" args =>+                     String ->+                       ArgsHMap "_backward_CachedOp(symbol)" args -> IO SymbolHandle+_backward_CachedOp name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_CachedOp"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SwapAxis(symbol)" =+     '[ '("dim1", AttrOpt Int), '("dim2", AttrOpt Int),+        '("data", AttrOpt SymbolHandle)]++_SwapAxis ::+          forall args . Fullfilled "_SwapAxis(symbol)" args =>+            String -> ArgsHMap "_SwapAxis(symbol)" args -> IO SymbolHandle+_SwapAxis name args+  = let scalarArgs+          = catMaybes+              [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int),+               ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SwapAxis"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Pad(symbol)" =+     '[ '("mode", AttrReq (EnumType '["constant", "edge", "reflect"])),+        '("pad_width", AttrReq [Int]), '("constant_value", AttrOpt Double),+        '("data", AttrOpt SymbolHandle)]++_Pad ::+     forall args . Fullfilled "_Pad(symbol)" args =>+       String -> ArgsHMap "_Pad(symbol)" args -> IO SymbolHandle+_Pad name args+  = let scalarArgs+          = catMaybes+              [("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["constant", "edge", "reflect"])),+               ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]),+               ("constant_value",) . showValue <$>+                 (args !? #constant_value :: Maybe Double)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pad"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_BatchNorm_v1(symbol)" =+     '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float),+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),+        '("output_mean_var", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle), '("gamma", AttrOpt SymbolHandle),+        '("beta", AttrOpt SymbolHandle)]++_BatchNorm_v1 ::+              forall args . Fullfilled "_BatchNorm_v1(symbol)" args =>+                String -> ArgsHMap "_BatchNorm_v1(symbol)" args -> IO SymbolHandle+_BatchNorm_v1 name args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),+               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BatchNorm_v1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sgd_update(symbol)" =+     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle)]++sgd_update ::+           forall args . Fullfilled "sgd_update(symbol)" args =>+             String -> ArgsHMap "sgd_update(symbol)" args -> IO SymbolHandle+sgd_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sgd_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sgd_mom_update(symbol)" =+     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("mom", AttrOpt SymbolHandle)]++sgd_mom_update ::+               forall args . Fullfilled "sgd_mom_update(symbol)" args =>+                 String -> ArgsHMap "sgd_mom_update(symbol)" args -> IO SymbolHandle+sgd_mom_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("mom",) <$> (args !? #mom :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sgd_mom_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "mp_sgd_update(symbol)" =+     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("weight32", AttrOpt SymbolHandle)]++mp_sgd_update ::+              forall args . Fullfilled "mp_sgd_update(symbol)" args =>+                String -> ArgsHMap "mp_sgd_update(symbol)" args -> IO SymbolHandle+mp_sgd_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mp_sgd_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "mp_sgd_mom_update(symbol)" =+     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("mom", AttrOpt SymbolHandle),+        '("weight32", AttrOpt SymbolHandle)]++mp_sgd_mom_update ::+                  forall args . Fullfilled "mp_sgd_mom_update(symbol)" args =>+                    String ->+                      ArgsHMap "mp_sgd_mom_update(symbol)" args -> IO SymbolHandle+mp_sgd_mom_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("mom",) <$> (args !? #mom :: Maybe SymbolHandle),+               ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mp_sgd_mom_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "adam_update(symbol)" =+     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),+        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("mean", AttrOpt SymbolHandle), '("var", AttrOpt SymbolHandle)]++adam_update ::+            forall args . Fullfilled "adam_update(symbol)" args =>+              String -> ArgsHMap "adam_update(symbol)" args -> IO SymbolHandle+adam_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("mean",) <$> (args !? #mean :: Maybe SymbolHandle),+               ("var",) <$> (args !? #var :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "adam_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "rmsprop_update(symbol)" =+     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),+        '("epsilon", AttrOpt Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("clip_weights", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("n", AttrOpt SymbolHandle)]++rmsprop_update ::+               forall args . Fullfilled "rmsprop_update(symbol)" args =>+                 String -> ArgsHMap "rmsprop_update(symbol)" args -> IO SymbolHandle+rmsprop_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("clip_weights",) . showValue <$>+                 (args !? #clip_weights :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("n",) <$> (args !? #n :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rmsprop_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "rmspropalex_update(symbol)" =+     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),+        '("gamma2", AttrOpt Float), '("epsilon", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("clip_weights", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("n", AttrOpt SymbolHandle), '("g", AttrOpt SymbolHandle),+        '("delta", AttrOpt SymbolHandle)]++rmspropalex_update ::+                   forall args . Fullfilled "rmspropalex_update(symbol)" args =>+                     String ->+                       ArgsHMap "rmspropalex_update(symbol)" args -> IO SymbolHandle+rmspropalex_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),+               ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("clip_weights",) . showValue <$>+                 (args !? #clip_weights :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("n",) <$> (args !? #n :: Maybe SymbolHandle),+               ("g",) <$> (args !? #g :: Maybe SymbolHandle),+               ("delta",) <$> (args !? #delta :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rmspropalex_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "ftrl_update(symbol)" =+     '[ '("lr", AttrReq Float), '("lamda1", AttrOpt Float),+        '("beta", AttrOpt Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("z", AttrOpt SymbolHandle), '("n", AttrOpt SymbolHandle)]++ftrl_update ::+            forall args . Fullfilled "ftrl_update(symbol)" args =>+              String -> ArgsHMap "ftrl_update(symbol)" args -> IO SymbolHandle+ftrl_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("z",) <$> (args !? #z :: Maybe SymbolHandle),+               ("n",) <$> (args !? #n :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ftrl_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_LeakyReLU(symbol)" =+     '[ '("act_type",+          AttrOpt (EnumType '["elu", "leaky", "prelu", "rrelu"])),+        '("slope", AttrOpt Float), '("lower_bound", AttrOpt Float),+        '("upper_bound", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_LeakyReLU ::+           forall args . Fullfilled "_LeakyReLU(symbol)" args =>+             String -> ArgsHMap "_LeakyReLU(symbol)" args -> IO SymbolHandle+_LeakyReLU name args+  = let scalarArgs+          = catMaybes+              [("act_type",) . showValue <$>+                 (args !? #act_type ::+                    Maybe (EnumType '["elu", "leaky", "prelu", "rrelu"])),+               ("slope",) . showValue <$> (args !? #slope :: Maybe Float),+               ("lower_bound",) . showValue <$>+                 (args !? #lower_bound :: Maybe Float),+               ("upper_bound",) . showValue <$>+                 (args !? #upper_bound :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LeakyReLU"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_IdentityAttachKLSparseReg(symbol)" =+     '[ '("sparseness_target", AttrOpt Float),+        '("penalty", AttrOpt Float), '("momentum", AttrOpt Float),+        '("data", AttrOpt SymbolHandle)]++_IdentityAttachKLSparseReg ::+                           forall args .+                             Fullfilled "_IdentityAttachKLSparseReg(symbol)" args =>+                             String ->+                               ArgsHMap "_IdentityAttachKLSparseReg(symbol)" args ->+                                 IO SymbolHandle+_IdentityAttachKLSparseReg name args+  = let scalarArgs+          = catMaybes+              [("sparseness_target",) . showValue <$>+                 (args !? #sparseness_target :: Maybe Float),+               ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "IdentityAttachKLSparseReg"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_UpSampling(symbol)" =+     '[ '("scale", AttrReq Int), '("num_filter", AttrOpt Int),+        '("sample_type", AttrReq (EnumType '["bilinear", "nearest"])),+        '("multi_input_mode", AttrOpt (EnumType '["concat", "sum"])),+        '("num_args", AttrReq Int), '("workspace", AttrOpt Int),+        '("data", AttrOpt [SymbolHandle])]++_UpSampling ::+            forall args . Fullfilled "_UpSampling(symbol)" args =>+              String -> ArgsHMap "_UpSampling(symbol)" args -> IO SymbolHandle+_UpSampling name args+  = let scalarArgs+          = catMaybes+              [("scale",) . showValue <$> (args !? #scale :: Maybe Int),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("sample_type",) . showValue <$>+                 (args !? #sample_type ::+                    Maybe (EnumType '["bilinear", "nearest"])),+               ("multi_input_mode",) . showValue <$>+                 (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])),+               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "UpSampling"+         sym <- if hasKey args #num_args then+                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals+                  else+                  mxSymbolCreateAtomicSymbol (fromOpHandle op)+                    ("num_args" : scalarkeys)+                    (showValue (length array) : scalarvals)+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_SliceChannel(symbol)" =+     '[ '("num_outputs", AttrReq Int), '("axis", AttrOpt Int),+        '("squeeze_axis", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++_SliceChannel ::+              forall args . Fullfilled "_SliceChannel(symbol)" args =>+                String -> ArgsHMap "_SliceChannel(symbol)" args -> IO SymbolHandle+_SliceChannel name args+  = let scalarArgs+          = catMaybes+              [("num_outputs",) . showValue <$>+                 (args !? #num_outputs :: Maybe Int),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("squeeze_axis",) . showValue <$>+                 (args !? #squeeze_axis :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SliceChannel"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_CuDNNBatchNorm(symbol)" =+     '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float),+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),+        '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int),+        '("cudnn_off", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++_CuDNNBatchNorm ::+                forall args . Fullfilled "_CuDNNBatchNorm(symbol)" args =>+                  String ->+                    ArgsHMap "_CuDNNBatchNorm(symbol)" args -> IO SymbolHandle+_CuDNNBatchNorm name args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "CuDNNBatchNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "softmax_cross_entropy(symbol)" =+     '[ '("data", AttrOpt SymbolHandle),+        '("label", AttrOpt SymbolHandle)]++softmax_cross_entropy ::+                      forall args . Fullfilled "softmax_cross_entropy(symbol)" args =>+                        String ->+                          ArgsHMap "softmax_cross_entropy(symbol)" args -> IO SymbolHandle+softmax_cross_entropy name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softmax_cross_entropy"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward_softmax_cross_entropy(symbol)" = '[]++_backward_softmax_cross_entropy ::+                                forall args .+                                  Fullfilled "_backward_softmax_cross_entropy(symbol)" args =>+                                  String ->+                                    ArgsHMap "_backward_softmax_cross_entropy(symbol)" args ->+                                      IO SymbolHandle+_backward_softmax_cross_entropy name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_softmax_cross_entropy"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Concat(symbol)" =+     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),+        '("data", AttrOpt [SymbolHandle])]++_Concat ::+        forall args . Fullfilled "_Concat(symbol)" args =>+          String -> ArgsHMap "_Concat(symbol)" args -> IO SymbolHandle+_Concat name args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "Concat"+         sym <- if hasKey args #num_args then+                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals+                  else+                  mxSymbolCreateAtomicSymbol (fromOpHandle op)+                    ("num_args" : scalarkeys)+                    (showValue (length array) : scalarvals)+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_BatchNorm(symbol)" =+     '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float),+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),+        '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int),+        '("cudnn_off", AttrOpt Bool), '("data", AttrOpt SymbolHandle),+        '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle),+        '("moving_mean", AttrOpt SymbolHandle),+        '("moving_var", AttrOpt SymbolHandle)]++_BatchNorm ::+           forall args . Fullfilled "_BatchNorm(symbol)" args =>+             String -> ArgsHMap "_BatchNorm(symbol)" args -> IO SymbolHandle+_BatchNorm name args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),+               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle),+               ("moving_mean",) <$> (args !? #moving_mean :: Maybe SymbolHandle),+               ("moving_var",) <$> (args !? #moving_var :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BatchNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_CustomFunction(symbol)" = '[]++_CustomFunction ::+                forall args . Fullfilled "_CustomFunction(symbol)" args =>+                  String ->+                    ArgsHMap "_CustomFunction(symbol)" args -> IO SymbolHandle+_CustomFunction name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_CustomFunction"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_CustomFunction(symbol)" =+     '[]++_backward_CustomFunction ::+                         forall args . Fullfilled "_backward_CustomFunction(symbol)" args =>+                           String ->+                             ArgsHMap "_backward_CustomFunction(symbol)" args -> IO SymbolHandle+_backward_CustomFunction name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_CustomFunction"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_MultiBoxTarget(symbol)" =+     '[ '("overlap_threshold", AttrOpt Float),+        '("ignore_label", AttrOpt Float),+        '("negative_mining_ratio", AttrOpt Float),+        '("negative_mining_thresh", AttrOpt Float),+        '("minimum_negative_samples", AttrOpt Int),+        '("variances", AttrOpt [Float]), '("anchor", AttrOpt SymbolHandle),+        '("label", AttrOpt SymbolHandle),+        '("cls_pred", AttrOpt SymbolHandle)]++_contrib_MultiBoxTarget ::+                        forall args . Fullfilled "_contrib_MultiBoxTarget(symbol)" args =>+                          String ->+                            ArgsHMap "_contrib_MultiBoxTarget(symbol)" args -> IO SymbolHandle+_contrib_MultiBoxTarget name args+  = let scalarArgs+          = catMaybes+              [("overlap_threshold",) . showValue <$>+                 (args !? #overlap_threshold :: Maybe Float),+               ("ignore_label",) . showValue <$>+                 (args !? #ignore_label :: Maybe Float),+               ("negative_mining_ratio",) . showValue <$>+                 (args !? #negative_mining_ratio :: Maybe Float),+               ("negative_mining_thresh",) . showValue <$>+                 (args !? #negative_mining_thresh :: Maybe Float),+               ("minimum_negative_samples",) . showValue <$>+                 (args !? #minimum_negative_samples :: Maybe Int),+               ("variances",) . showValue <$>+                 (args !? #variances :: Maybe [Float])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("anchor",) <$> (args !? #anchor :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle),+               ("cls_pred",) <$> (args !? #cls_pred :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxTarget"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_MultiBoxTarget(symbol)" = '[]++_backward__contrib_MultiBoxTarget ::+                                  forall args .+                                    Fullfilled "_backward__contrib_MultiBoxTarget(symbol)" args =>+                                    String ->+                                      ArgsHMap "_backward__contrib_MultiBoxTarget(symbol)" args ->+                                        IO SymbolHandle+_backward__contrib_MultiBoxTarget name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_Proposal(symbol)" =+     '[ '("rpn_pre_nms_top_n", AttrOpt Int),+        '("rpn_post_nms_top_n", AttrOpt Int),+        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),+        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),+        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),+        '("iou_loss", AttrOpt Bool), '("cls_score", AttrOpt SymbolHandle),+        '("bbox_pred", AttrOpt SymbolHandle),+        '("im_info", AttrOpt SymbolHandle)]++_contrib_Proposal ::+                  forall args . Fullfilled "_contrib_Proposal(symbol)" args =>+                    String ->+                      ArgsHMap "_contrib_Proposal(symbol)" args -> IO SymbolHandle+_contrib_Proposal name args+  = let scalarArgs+          = catMaybes+              [("rpn_pre_nms_top_n",) . showValue <$>+                 (args !? #rpn_pre_nms_top_n :: Maybe Int),+               ("rpn_post_nms_top_n",) . showValue <$>+                 (args !? #rpn_post_nms_top_n :: Maybe Int),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("rpn_min_size",) . showValue <$>+                 (args !? #rpn_min_size :: Maybe Int),+               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("feature_stride",) . showValue <$>+                 (args !? #feature_stride :: Maybe Int),+               ("output_score",) . showValue <$>+                 (args !? #output_score :: Maybe Bool),+               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("cls_score",) <$> (args !? #cls_score :: Maybe SymbolHandle),+               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe SymbolHandle),+               ("im_info",) <$> (args !? #im_info :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_Proposal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward__contrib_Proposal(symbol)" =+     '[]++_backward__contrib_Proposal ::+                            forall args .+                              Fullfilled "_backward__contrib_Proposal(symbol)" args =>+                              String ->+                                ArgsHMap "_backward__contrib_Proposal(symbol)" args ->+                                  IO SymbolHandle+_backward__contrib_Proposal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_Proposal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_count_sketch(symbol)" =+     '[ '("out_dim", AttrReq Int),+        '("processing_batch_size", AttrOpt Int),+        '("data", AttrOpt SymbolHandle), '("h", AttrOpt SymbolHandle),+        '("s", AttrOpt SymbolHandle)]++_contrib_count_sketch ::+                      forall args . Fullfilled "_contrib_count_sketch(symbol)" args =>+                        String ->+                          ArgsHMap "_contrib_count_sketch(symbol)" args -> IO SymbolHandle+_contrib_count_sketch name args+  = let scalarArgs+          = catMaybes+              [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int),+               ("processing_batch_size",) . showValue <$>+                 (args !? #processing_batch_size :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("h",) <$> (args !? #h :: Maybe SymbolHandle),+               ("s",) <$> (args !? #s :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_count_sketch"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_count_sketch(symbol)" = '[]++_backward__contrib_count_sketch ::+                                forall args .+                                  Fullfilled "_backward__contrib_count_sketch(symbol)" args =>+                                  String ->+                                    ArgsHMap "_backward__contrib_count_sketch(symbol)" args ->+                                      IO SymbolHandle+_backward__contrib_count_sketch name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_count_sketch"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_MultiBoxDetection(symbol)" =+     '[ '("clip", AttrOpt Bool), '("threshold", AttrOpt Float),+        '("background_id", AttrOpt Int), '("nms_threshold", AttrOpt Float),+        '("force_suppress", AttrOpt Bool), '("variances", AttrOpt [Float]),+        '("nms_topk", AttrOpt Int), '("cls_prob", AttrOpt SymbolHandle),+        '("loc_pred", AttrOpt SymbolHandle),+        '("anchor", AttrOpt SymbolHandle)]++_contrib_MultiBoxDetection ::+                           forall args .+                             Fullfilled "_contrib_MultiBoxDetection(symbol)" args =>+                             String ->+                               ArgsHMap "_contrib_MultiBoxDetection(symbol)" args ->+                                 IO SymbolHandle+_contrib_MultiBoxDetection name args+  = let scalarArgs+          = catMaybes+              [("clip",) . showValue <$> (args !? #clip :: Maybe Bool),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("background_id",) . showValue <$>+                 (args !? #background_id :: Maybe Int),+               ("nms_threshold",) . showValue <$>+                 (args !? #nms_threshold :: Maybe Float),+               ("force_suppress",) . showValue <$>+                 (args !? #force_suppress :: Maybe Bool),+               ("variances",) . showValue <$>+                 (args !? #variances :: Maybe [Float]),+               ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle),+               ("loc_pred",) <$> (args !? #loc_pred :: Maybe SymbolHandle),+               ("anchor",) <$> (args !? #anchor :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxDetection"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_MultiBoxDetection(symbol)" = '[]++_backward__contrib_MultiBoxDetection ::+                                     forall args .+                                       Fullfilled "_backward__contrib_MultiBoxDetection(symbol)"+                                         args =>+                                       String ->+                                         ArgsHMap "_backward__contrib_MultiBoxDetection(symbol)"+                                           args+                                           -> IO SymbolHandle+_backward__contrib_MultiBoxDetection name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_PSROIPooling(symbol)" =+     '[ '("spatial_scale", AttrReq Float), '("output_dim", AttrReq Int),+        '("pooled_size", AttrReq Int), '("group_size", AttrOpt Int),+        '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle)]++_contrib_PSROIPooling ::+                      forall args . Fullfilled "_contrib_PSROIPooling(symbol)" args =>+                        String ->+                          ArgsHMap "_contrib_PSROIPooling(symbol)" args -> IO SymbolHandle+_contrib_PSROIPooling name args+  = let scalarArgs+          = catMaybes+              [("spatial_scale",) . showValue <$>+                 (args !? #spatial_scale :: Maybe Float),+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),+               ("pooled_size",) . showValue <$>+                 (args !? #pooled_size :: Maybe Int),+               ("group_size",) . showValue <$> (args !? #group_size :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_PSROIPooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_PSROIPooling(symbol)" = '[]++_backward__contrib_PSROIPooling ::+                                forall args .+                                  Fullfilled "_backward__contrib_PSROIPooling(symbol)" args =>+                                  String ->+                                    ArgsHMap "_backward__contrib_PSROIPooling(symbol)" args ->+                                      IO SymbolHandle+_backward__contrib_PSROIPooling name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_PSROIPooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_contrib_DeformablePSROIPooling(symbol)" =+     '[ '("spatial_scale", AttrReq Float), '("output_dim", AttrReq Int),+        '("group_size", AttrReq Int), '("pooled_size", AttrReq Int),+        '("part_size", AttrOpt Int), '("sample_per_part", AttrOpt Int),+        '("trans_std", AttrOpt Float), '("no_trans", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle),+        '("trans", AttrOpt SymbolHandle)]++_contrib_DeformablePSROIPooling ::+                                forall args .+                                  Fullfilled "_contrib_DeformablePSROIPooling(symbol)" args =>+                                  String ->+                                    ArgsHMap "_contrib_DeformablePSROIPooling(symbol)" args ->+                                      IO SymbolHandle+_contrib_DeformablePSROIPooling name args+  = let scalarArgs+          = catMaybes+              [("spatial_scale",) . showValue <$>+                 (args !? #spatial_scale :: Maybe Float),+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),+               ("group_size",) . showValue <$> (args !? #group_size :: Maybe Int),+               ("pooled_size",) . showValue <$>+                 (args !? #pooled_size :: Maybe Int),+               ("part_size",) . showValue <$> (args !? #part_size :: Maybe Int),+               ("sample_per_part",) . showValue <$>+                 (args !? #sample_per_part :: Maybe Int),+               ("trans_std",) . showValue <$> (args !? #trans_std :: Maybe Float),+               ("no_trans",) . showValue <$> (args !? #no_trans :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle),+               ("trans",) <$> (args !? #trans :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_DeformablePSROIPooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_DeformablePSROIPooling(symbol)" =+     '[]++_backward__contrib_DeformablePSROIPooling ::+                                          forall args .+                                            Fullfilled+                                              "_backward__contrib_DeformablePSROIPooling(symbol)"+                                              args =>+                                            String ->+                                              ArgsHMap+                                                "_backward__contrib_DeformablePSROIPooling(symbol)"+                                                args+                                                -> IO SymbolHandle+_backward__contrib_DeformablePSROIPooling name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward__contrib_CTCLoss(symbol)" =+     '[]++_backward__contrib_CTCLoss ::+                           forall args .+                             Fullfilled "_backward__contrib_CTCLoss(symbol)" args =>+                             String ->+                               ArgsHMap "_backward__contrib_CTCLoss(symbol)" args ->+                                 IO SymbolHandle+_backward__contrib_CTCLoss name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_CTCLoss"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_MultiProposal(symbol)" =+     '[ '("rpn_pre_nms_top_n", AttrOpt Int),+        '("rpn_post_nms_top_n", AttrOpt Int),+        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),+        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),+        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),+        '("iou_loss", AttrOpt Bool), '("cls_score", AttrOpt SymbolHandle),+        '("bbox_pred", AttrOpt SymbolHandle),+        '("im_info", AttrOpt SymbolHandle)]++_contrib_MultiProposal ::+                       forall args . Fullfilled "_contrib_MultiProposal(symbol)" args =>+                         String ->+                           ArgsHMap "_contrib_MultiProposal(symbol)" args -> IO SymbolHandle+_contrib_MultiProposal name args+  = let scalarArgs+          = catMaybes+              [("rpn_pre_nms_top_n",) . showValue <$>+                 (args !? #rpn_pre_nms_top_n :: Maybe Int),+               ("rpn_post_nms_top_n",) . showValue <$>+                 (args !? #rpn_post_nms_top_n :: Maybe Int),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("rpn_min_size",) . showValue <$>+                 (args !? #rpn_min_size :: Maybe Int),+               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("feature_stride",) . showValue <$>+                 (args !? #feature_stride :: Maybe Int),+               ("output_score",) . showValue <$>+                 (args !? #output_score :: Maybe Bool),+               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("cls_score",) <$> (args !? #cls_score :: Maybe SymbolHandle),+               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe SymbolHandle),+               ("im_info",) <$> (args !? #im_info :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiProposal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_MultiProposal(symbol)" = '[]++_backward__contrib_MultiProposal ::+                                 forall args .+                                   Fullfilled "_backward__contrib_MultiProposal(symbol)" args =>+                                   String ->+                                     ArgsHMap "_backward__contrib_MultiProposal(symbol)" args ->+                                       IO SymbolHandle+_backward__contrib_MultiProposal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiProposal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_MultiBoxPrior(symbol)" =+     '[ '("sizes", AttrOpt [Float]), '("ratios", AttrOpt [Float]),+        '("clip", AttrOpt Bool), '("steps", AttrOpt [Float]),+        '("offsets", AttrOpt [Float]), '("data", AttrOpt SymbolHandle)]++_contrib_MultiBoxPrior ::+                       forall args . Fullfilled "_contrib_MultiBoxPrior(symbol)" args =>+                         String ->+                           ArgsHMap "_contrib_MultiBoxPrior(symbol)" args -> IO SymbolHandle+_contrib_MultiBoxPrior name args+  = let scalarArgs+          = catMaybes+              [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("clip",) . showValue <$> (args !? #clip :: Maybe Bool),+               ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]),+               ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxPrior"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_MultiBoxPrior(symbol)" = '[]++_backward__contrib_MultiBoxPrior ::+                                 forall args .+                                   Fullfilled "_backward__contrib_MultiBoxPrior(symbol)" args =>+                                   String ->+                                     ArgsHMap "_backward__contrib_MultiBoxPrior(symbol)" args ->+                                       IO SymbolHandle+_backward__contrib_MultiBoxPrior name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_fft(symbol)" =+     '[ '("compute_size", AttrOpt Int), '("data", AttrOpt SymbolHandle)]++_contrib_fft ::+             forall args . Fullfilled "_contrib_fft(symbol)" args =>+               String -> ArgsHMap "_contrib_fft(symbol)" args -> IO SymbolHandle+_contrib_fft name args+  = let scalarArgs+          = catMaybes+              [("compute_size",) . showValue <$>+                 (args !? #compute_size :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_fft"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward__contrib_fft(symbol)" = '[]++_backward__contrib_fft ::+                       forall args . Fullfilled "_backward__contrib_fft(symbol)" args =>+                         String ->+                           ArgsHMap "_backward__contrib_fft(symbol)" args -> IO SymbolHandle+_backward__contrib_fft name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_fft"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_contrib_DeformableConvolution(symbol)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("num_deformable_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("layout", AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NCW"]))),+        '("data", AttrOpt SymbolHandle), '("offset", AttrOpt SymbolHandle),+        '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle)]++_contrib_DeformableConvolution ::+                               forall args .+                                 Fullfilled "_contrib_DeformableConvolution(symbol)" args =>+                                 String ->+                                   ArgsHMap "_contrib_DeformableConvolution(symbol)" args ->+                                     IO SymbolHandle+_contrib_DeformableConvolution name args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("num_deformable_group",) . showValue <$>+                 (args !? #num_deformable_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("offset",) <$> (args !? #offset :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_DeformableConvolution"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_DeformableConvolution(symbol)" =+     '[]++_backward__contrib_DeformableConvolution ::+                                         forall args .+                                           Fullfilled+                                             "_backward__contrib_DeformableConvolution(symbol)"+                                             args =>+                                           String ->+                                             ArgsHMap+                                               "_backward__contrib_DeformableConvolution(symbol)"+                                               args+                                               -> IO SymbolHandle+_backward__contrib_DeformableConvolution name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_ifft(symbol)" =+     '[ '("compute_size", AttrOpt Int), '("data", AttrOpt SymbolHandle)]++_contrib_ifft ::+              forall args . Fullfilled "_contrib_ifft(symbol)" args =>+                String -> ArgsHMap "_contrib_ifft(symbol)" args -> IO SymbolHandle+_contrib_ifft name args+  = let scalarArgs+          = catMaybes+              [("compute_size",) . showValue <$>+                 (args !? #compute_size :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_ifft"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward__contrib_ifft(symbol)" = '[]++_backward__contrib_ifft ::+                        forall args . Fullfilled "_backward__contrib_ifft(symbol)" args =>+                          String ->+                            ArgsHMap "_backward__contrib_ifft(symbol)" args -> IO SymbolHandle+_backward__contrib_ifft name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_ifft"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward__Native(symbol)" = '[]++_backward__Native ::+                  forall args . Fullfilled "_backward__Native(symbol)" args =>+                    String ->+                      ArgsHMap "_backward__Native(symbol)" args -> IO SymbolHandle+_backward__Native name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__Native"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward__NDArray(symbol)" = '[]++_backward__NDArray ::+                   forall args . Fullfilled "_backward__NDArray(symbol)" args =>+                     String ->+                       ArgsHMap "_backward__NDArray(symbol)" args -> IO SymbolHandle+_backward__NDArray name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__NDArray"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_InstanceNorm(symbol)" =+     '[ '("eps", AttrOpt Float), '("data", AttrOpt SymbolHandle),+        '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle)]++_InstanceNorm ::+              forall args . Fullfilled "_InstanceNorm(symbol)" args =>+                String -> ArgsHMap "_InstanceNorm(symbol)" args -> IO SymbolHandle+_InstanceNorm name args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),+               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "InstanceNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_InstanceNorm(symbol)" = '[]++_backward_InstanceNorm ::+                       forall args . Fullfilled "_backward_InstanceNorm(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_InstanceNorm(symbol)" args -> IO SymbolHandle+_backward_InstanceNorm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_InstanceNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SVMOutput(symbol)" =+     '[ '("margin", AttrOpt Float),+        '("regularization_coefficient", AttrOpt Float),+        '("use_linear", AttrOpt Bool), '("data", AttrOpt SymbolHandle),+        '("label", AttrOpt SymbolHandle)]++_SVMOutput ::+           forall args . Fullfilled "_SVMOutput(symbol)" args =>+             String -> ArgsHMap "_SVMOutput(symbol)" args -> IO SymbolHandle+_SVMOutput name args+  = let scalarArgs+          = catMaybes+              [("margin",) . showValue <$> (args !? #margin :: Maybe Float),+               ("regularization_coefficient",) . showValue <$>+                 (args !? #regularization_coefficient :: Maybe Float),+               ("use_linear",) . showValue <$>+                 (args !? #use_linear :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SVMOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SVMOutput(symbol)" = '[]++_backward_SVMOutput ::+                    forall args . Fullfilled "_backward_SVMOutput(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_SVMOutput(symbol)" args -> IO SymbolHandle+_backward_SVMOutput name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SVMOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Pooling(symbol)" =+     '[ '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool),+        '("kernel", AttrReq [Int]),+        '("pool_type", AttrReq (EnumType '["avg", "max", "sum"])),+        '("pooling_convention", AttrOpt (EnumType '["full", "valid"])),+        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("data", AttrOpt SymbolHandle)]++_Pooling ::+         forall args . Fullfilled "_Pooling(symbol)" args =>+           String -> ArgsHMap "_Pooling(symbol)" args -> IO SymbolHandle+_Pooling name args+  = let scalarArgs+          = catMaybes+              [("global_pool",) . showValue <$>+                 (args !? #global_pool :: Maybe Bool),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("pool_type",) . showValue <$>+                 (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])),+               ("pooling_convention",) . showValue <$>+                 (args !? #pooling_convention ::+                    Maybe (EnumType '["full", "valid"])),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Pooling(symbol)" = '[]++_backward_Pooling ::+                  forall args . Fullfilled "_backward_Pooling(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_Pooling(symbol)" args -> IO SymbolHandle+_backward_Pooling name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Convolution_v1(symbol)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("cudnn_tune",+          AttrOpt+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+        '("cudnn_off", AttrOpt Bool),+        '("layout",+          AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"]))),+        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),+        '("bias", AttrOpt SymbolHandle)]++_Convolution_v1 ::+                forall args . Fullfilled "_Convolution_v1(symbol)" args =>+                  String ->+                    ArgsHMap "_Convolution_v1(symbol)" args -> IO SymbolHandle+_Convolution_v1 name args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Convolution_v1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Convolution_v1(symbol)" =+     '[]++_backward_Convolution_v1 ::+                         forall args . Fullfilled "_backward_Convolution_v1(symbol)" args =>+                           String ->+                             ArgsHMap "_backward_Convolution_v1(symbol)" args -> IO SymbolHandle+_backward_Convolution_v1 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Convolution_v1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Crop(symbol)" =+     '[ '("num_args", AttrReq Int), '("offset", AttrOpt [Int]),+        '("h_w", AttrOpt [Int]), '("center_crop", AttrOpt Bool),+        '("data", AttrOpt [SymbolHandle])]++_Crop ::+      forall args . Fullfilled "_Crop(symbol)" args =>+        String -> ArgsHMap "_Crop(symbol)" args -> IO SymbolHandle+_Crop name args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]),+               ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]),+               ("center_crop",) . showValue <$>+                 (args !? #center_crop :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "Crop"+         sym <- if hasKey args #num_args then+                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals+                  else+                  mxSymbolCreateAtomicSymbol (fromOpHandle op)+                    ("num_args" : scalarkeys)+                    (showValue (length array) : scalarvals)+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_backward_Crop(symbol)" = '[]++_backward_Crop ::+               forall args . Fullfilled "_backward_Crop(symbol)" args =>+                 String -> ArgsHMap "_backward_Crop(symbol)" args -> IO SymbolHandle+_backward_Crop name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Crop"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SpatialTransformer(symbol)" =+     '[ '("target_shape", AttrOpt [Int]),+        '("transform_type", AttrReq (EnumType '["affine"])),+        '("sampler_type", AttrReq (EnumType '["bilinear"])),+        '("data", AttrOpt SymbolHandle), '("loc", AttrOpt SymbolHandle)]++_SpatialTransformer ::+                    forall args . Fullfilled "_SpatialTransformer(symbol)" args =>+                      String ->+                        ArgsHMap "_SpatialTransformer(symbol)" args -> IO SymbolHandle+_SpatialTransformer name args+  = let scalarArgs+          = catMaybes+              [("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("transform_type",) . showValue <$>+                 (args !? #transform_type :: Maybe (EnumType '["affine"])),+               ("sampler_type",) . showValue <$>+                 (args !? #sampler_type :: Maybe (EnumType '["bilinear"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("loc",) <$> (args !? #loc :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SpatialTransformer"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SpatialTransformer(symbol)"+     = '[]++_backward_SpatialTransformer ::+                             forall args .+                               Fullfilled "_backward_SpatialTransformer(symbol)" args =>+                               String ->+                                 ArgsHMap "_backward_SpatialTransformer(symbol)" args ->+                                   IO SymbolHandle+_backward_SpatialTransformer name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SpatialTransformer"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SwapAxis(symbol)" = '[]++_backward_SwapAxis ::+                   forall args . Fullfilled "_backward_SwapAxis(symbol)" args =>+                     String ->+                       ArgsHMap "_backward_SwapAxis(symbol)" args -> IO SymbolHandle+_backward_SwapAxis name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SwapAxis"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_LinearRegressionOutput(symbol)" =+     '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle),+        '("label", AttrOpt SymbolHandle)]++_LinearRegressionOutput ::+                        forall args . Fullfilled "_LinearRegressionOutput(symbol)" args =>+                          String ->+                            ArgsHMap "_LinearRegressionOutput(symbol)" args -> IO SymbolHandle+_LinearRegressionOutput name args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LinearRegressionOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward_LinearRegressionOutput(symbol)" = '[]++_backward_LinearRegressionOutput ::+                                 forall args .+                                   Fullfilled "_backward_LinearRegressionOutput(symbol)" args =>+                                   String ->+                                     ArgsHMap "_backward_LinearRegressionOutput(symbol)" args ->+                                       IO SymbolHandle+_backward_LinearRegressionOutput name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LinearRegressionOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_MAERegressionOutput(symbol)" =+     '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle),+        '("label", AttrOpt SymbolHandle)]++_MAERegressionOutput ::+                     forall args . Fullfilled "_MAERegressionOutput(symbol)" args =>+                       String ->+                         ArgsHMap "_MAERegressionOutput(symbol)" args -> IO SymbolHandle+_MAERegressionOutput name args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "MAERegressionOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_MAERegressionOutput(symbol)"+     = '[]++_backward_MAERegressionOutput ::+                              forall args .+                                Fullfilled "_backward_MAERegressionOutput(symbol)" args =>+                                String ->+                                  ArgsHMap "_backward_MAERegressionOutput(symbol)" args ->+                                    IO SymbolHandle+_backward_MAERegressionOutput name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_MAERegressionOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_LogisticRegressionOutput(symbol)" =+     '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle),+        '("label", AttrOpt SymbolHandle)]++_LogisticRegressionOutput ::+                          forall args .+                            Fullfilled "_LogisticRegressionOutput(symbol)" args =>+                            String ->+                              ArgsHMap "_LogisticRegressionOutput(symbol)" args ->+                                IO SymbolHandle+_LogisticRegressionOutput name args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LogisticRegressionOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward_LogisticRegressionOutput(symbol)" = '[]++_backward_LogisticRegressionOutput ::+                                   forall args .+                                     Fullfilled "_backward_LogisticRegressionOutput(symbol)" args =>+                                     String ->+                                       ArgsHMap "_backward_LogisticRegressionOutput(symbol)" args ->+                                         IO SymbolHandle+_backward_LogisticRegressionOutput name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LogisticRegressionOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Pad(symbol)" = '[]++_backward_Pad ::+              forall args . Fullfilled "_backward_Pad(symbol)" args =>+                String -> ArgsHMap "_backward_Pad(symbol)" args -> IO SymbolHandle+_backward_Pad name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pad"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SoftmaxOutput(symbol)" =+     '[ '("grad_scale", AttrOpt Float),+        '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool),+        '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool),+        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),+        '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float),+        '("data", AttrOpt SymbolHandle), '("label", AttrOpt SymbolHandle)]++_SoftmaxOutput ::+               forall args . Fullfilled "_SoftmaxOutput(symbol)" args =>+                 String -> ArgsHMap "_SoftmaxOutput(symbol)" args -> IO SymbolHandle+_SoftmaxOutput name args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float),+               ("ignore_label",) . showValue <$>+                 (args !? #ignore_label :: Maybe Float),+               ("multi_output",) . showValue <$>+                 (args !? #multi_output :: Maybe Bool),+               ("use_ignore",) . showValue <$>+                 (args !? #use_ignore :: Maybe Bool),+               ("preserve_shape",) . showValue <$>+                 (args !? #preserve_shape :: Maybe Bool),+               ("normalization",) . showValue <$>+                 (args !? #normalization ::+                    Maybe (EnumType '["batch", "null", "valid"])),+               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),+               ("smooth_alpha",) . showValue <$>+                 (args !? #smooth_alpha :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SoftmaxOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SoftmaxOutput(symbol)" = '[]++_backward_SoftmaxOutput ::+                        forall args . Fullfilled "_backward_SoftmaxOutput(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_SoftmaxOutput(symbol)" args -> IO SymbolHandle+_backward_SoftmaxOutput name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SoftmaxOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Softmax(symbol)" =+     '[ '("grad_scale", AttrOpt Float),+        '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool),+        '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool),+        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),+        '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float),+        '("data", AttrOpt SymbolHandle)]++_Softmax ::+         forall args . Fullfilled "_Softmax(symbol)" args =>+           String -> ArgsHMap "_Softmax(symbol)" args -> IO SymbolHandle+_Softmax name args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float),+               ("ignore_label",) . showValue <$>+                 (args !? #ignore_label :: Maybe Float),+               ("multi_output",) . showValue <$>+                 (args !? #multi_output :: Maybe Bool),+               ("use_ignore",) . showValue <$>+                 (args !? #use_ignore :: Maybe Bool),+               ("preserve_shape",) . showValue <$>+                 (args !? #preserve_shape :: Maybe Bool),+               ("normalization",) . showValue <$>+                 (args !? #normalization ::+                    Maybe (EnumType '["batch", "null", "valid"])),+               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),+               ("smooth_alpha",) . showValue <$>+                 (args !? #smooth_alpha :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Softmax"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Softmax(symbol)" = '[]++_backward_Softmax ::+                  forall args . Fullfilled "_backward_Softmax(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_Softmax(symbol)" args -> IO SymbolHandle+_backward_Softmax name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Softmax"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SequenceReverse(symbol)" =+     '[ '("use_sequence_length", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle),+        '("sequence_length", AttrOpt SymbolHandle)]++_SequenceReverse ::+                 forall args . Fullfilled "_SequenceReverse(symbol)" args =>+                   String ->+                     ArgsHMap "_SequenceReverse(symbol)" args -> IO SymbolHandle+_SequenceReverse name args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceReverse"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SequenceReverse(symbol)" =+     '[]++_backward_SequenceReverse ::+                          forall args .+                            Fullfilled "_backward_SequenceReverse(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_SequenceReverse(symbol)" args ->+                                IO SymbolHandle+_backward_SequenceReverse name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceReverse"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_BatchNorm_v1(symbol)" = '[]++_backward_BatchNorm_v1 ::+                       forall args . Fullfilled "_backward_BatchNorm_v1(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_BatchNorm_v1(symbol)" args -> IO SymbolHandle+_backward_BatchNorm_v1 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BatchNorm_v1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SequenceLast(symbol)" =+     '[ '("use_sequence_length", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle),+        '("sequence_length", AttrOpt SymbolHandle)]++_SequenceLast ::+              forall args . Fullfilled "_SequenceLast(symbol)" args =>+                String -> ArgsHMap "_SequenceLast(symbol)" args -> IO SymbolHandle+_SequenceLast name args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceLast"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SequenceLast(symbol)" = '[]++_backward_SequenceLast ::+                       forall args . Fullfilled "_backward_SequenceLast(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_SequenceLast(symbol)" args -> IO SymbolHandle+_backward_SequenceLast name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceLast"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Correlation(symbol)" =+     '[ '("kernel_size", AttrOpt Int),+        '("max_displacement", AttrOpt Int), '("stride1", AttrOpt Int),+        '("stride2", AttrOpt Int), '("pad_size", AttrOpt Int),+        '("is_multiply", AttrOpt Bool), '("data1", AttrOpt SymbolHandle),+        '("data2", AttrOpt SymbolHandle)]++_Correlation ::+             forall args . Fullfilled "_Correlation(symbol)" args =>+               String -> ArgsHMap "_Correlation(symbol)" args -> IO SymbolHandle+_Correlation name args+  = let scalarArgs+          = catMaybes+              [("kernel_size",) . showValue <$>+                 (args !? #kernel_size :: Maybe Int),+               ("max_displacement",) . showValue <$>+                 (args !? #max_displacement :: Maybe Int),+               ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int),+               ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int),+               ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int),+               ("is_multiply",) . showValue <$>+                 (args !? #is_multiply :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data1",) <$> (args !? #data1 :: Maybe SymbolHandle),+               ("data2",) <$> (args !? #data2 :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Correlation"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Correlation(symbol)" = '[]++_backward_Correlation ::+                      forall args . Fullfilled "_backward_Correlation(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_Correlation(symbol)" args -> IO SymbolHandle+_backward_Correlation name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Correlation"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_MakeLoss(symbol)" =+     '[ '("grad_scale", AttrOpt Float),+        '("valid_thresh", AttrOpt Float),+        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),+        '("data", AttrOpt SymbolHandle)]++_MakeLoss ::+          forall args . Fullfilled "_MakeLoss(symbol)" args =>+            String -> ArgsHMap "_MakeLoss(symbol)" args -> IO SymbolHandle+_MakeLoss name args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float),+               ("valid_thresh",) . showValue <$>+                 (args !? #valid_thresh :: Maybe Float),+               ("normalization",) . showValue <$>+                 (args !? #normalization ::+                    Maybe (EnumType '["batch", "null", "valid"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "MakeLoss"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_MakeLoss(symbol)" = '[]++_backward_MakeLoss ::+                   forall args . Fullfilled "_backward_MakeLoss(symbol)" args =>+                     String ->+                       ArgsHMap "_backward_MakeLoss(symbol)" args -> IO SymbolHandle+_backward_MakeLoss name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_MakeLoss"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_LRN(symbol)" =+     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),+        '("knorm", AttrOpt Float), '("nsize", AttrReq Int),+        '("data", AttrOpt SymbolHandle)]++_LRN ::+     forall args . Fullfilled "_LRN(symbol)" args =>+       String -> ArgsHMap "_LRN(symbol)" args -> IO SymbolHandle+_LRN name args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float),+               ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LRN"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_LRN(symbol)" = '[]++_backward_LRN ::+              forall args . Fullfilled "_backward_LRN(symbol)" args =>+                String -> ArgsHMap "_backward_LRN(symbol)" args -> IO SymbolHandle+_backward_LRN name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LRN"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SequenceMask(symbol)" =+     '[ '("use_sequence_length", AttrOpt Bool),+        '("value", AttrOpt Float), '("data", AttrOpt SymbolHandle),+        '("sequence_length", AttrOpt SymbolHandle)]++_SequenceMask ::+              forall args . Fullfilled "_SequenceMask(symbol)" args =>+                String -> ArgsHMap "_SequenceMask(symbol)" args -> IO SymbolHandle+_SequenceMask name args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool),+               ("value",) . showValue <$> (args !? #value :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceMask"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SequenceMask(symbol)" = '[]++_backward_SequenceMask ::+                       forall args . Fullfilled "_backward_SequenceMask(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_SequenceMask(symbol)" args -> IO SymbolHandle+_backward_SequenceMask name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceMask"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_GridGenerator(symbol)" =+     '[ '("transform_type", AttrReq (EnumType '["affine", "warp"])),+        '("target_shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]++_GridGenerator ::+               forall args . Fullfilled "_GridGenerator(symbol)" args =>+                 String -> ArgsHMap "_GridGenerator(symbol)" args -> IO SymbolHandle+_GridGenerator name args+  = let scalarArgs+          = catMaybes+              [("transform_type",) . showValue <$>+                 (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "GridGenerator"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_GridGenerator(symbol)" = '[]++_backward_GridGenerator ::+                        forall args . Fullfilled "_backward_GridGenerator(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_GridGenerator(symbol)" args -> IO SymbolHandle+_backward_GridGenerator name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_GridGenerator"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Pooling_v1(symbol)" =+     '[ '("global_pool", AttrOpt Bool), '("kernel", AttrReq [Int]),+        '("pool_type", AttrReq (EnumType '["avg", "max", "sum"])),+        '("pooling_convention", AttrOpt (EnumType '["full", "valid"])),+        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("data", AttrOpt SymbolHandle)]++_Pooling_v1 ::+            forall args . Fullfilled "_Pooling_v1(symbol)" args =>+              String -> ArgsHMap "_Pooling_v1(symbol)" args -> IO SymbolHandle+_Pooling_v1 name args+  = let scalarArgs+          = catMaybes+              [("global_pool",) . showValue <$>+                 (args !? #global_pool :: Maybe Bool),+               ("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("pool_type",) . showValue <$>+                 (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])),+               ("pooling_convention",) . showValue <$>+                 (args !? #pooling_convention ::+                    Maybe (EnumType '["full", "valid"])),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pooling_v1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Pooling_v1(symbol)" = '[]++_backward_Pooling_v1 ::+                     forall args . Fullfilled "_backward_Pooling_v1(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_Pooling_v1(symbol)" args -> IO SymbolHandle+_backward_Pooling_v1 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pooling_v1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_LeakyReLU(symbol)" = '[]++_backward_LeakyReLU ::+                    forall args . Fullfilled "_backward_LeakyReLU(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_LeakyReLU(symbol)" args -> IO SymbolHandle+_backward_LeakyReLU name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LeakyReLU"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward_IdentityAttachKLSparseReg(symbol)" = '[]++_backward_IdentityAttachKLSparseReg ::+                                    forall args .+                                      Fullfilled "_backward_IdentityAttachKLSparseReg(symbol)"+                                        args =>+                                      String ->+                                        ArgsHMap "_backward_IdentityAttachKLSparseReg(symbol)" args+                                          -> IO SymbolHandle+_backward_IdentityAttachKLSparseReg name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Activation(symbol)" =+     '[ '("act_type",+          AttrReq (EnumType '["relu", "sigmoid", "softrelu", "tanh"])),+        '("data", AttrOpt SymbolHandle)]++_Activation ::+            forall args . Fullfilled "_Activation(symbol)" args =>+              String -> ArgsHMap "_Activation(symbol)" args -> IO SymbolHandle+_Activation name args+  = let scalarArgs+          = catMaybes+              [("act_type",) . showValue <$>+                 (args !? #act_type ::+                    Maybe (EnumType '["relu", "sigmoid", "softrelu", "tanh"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Activation"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Activation(symbol)" = '[]++_backward_Activation ::+                     forall args . Fullfilled "_backward_Activation(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_Activation(symbol)" args -> IO SymbolHandle+_backward_Activation name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Activation"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_UpSampling(symbol)" = '[]++_backward_UpSampling ::+                     forall args . Fullfilled "_backward_UpSampling(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_UpSampling(symbol)" args -> IO SymbolHandle+_backward_UpSampling name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_UpSampling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Deconvolution(symbol)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("adj", AttrOpt [Int]), '("target_shape", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("cudnn_tune",+          AttrOpt+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+        '("cudnn_off", AttrOpt Bool),+        '("layout",+          AttrOpt+            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),+        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),+        '("bias", AttrOpt SymbolHandle)]++_Deconvolution ::+               forall args . Fullfilled "_Deconvolution(symbol)" args =>+                 String -> ArgsHMap "_Deconvolution(symbol)" args -> IO SymbolHandle+_Deconvolution name args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Deconvolution"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Deconvolution(symbol)" = '[]++_backward_Deconvolution ::+                        forall args . Fullfilled "_backward_Deconvolution(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_Deconvolution(symbol)" args -> IO SymbolHandle+_backward_Deconvolution name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Deconvolution"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_BilinearSampler(symbol)" =+     '[ '("data", AttrOpt SymbolHandle),+        '("grid", AttrOpt SymbolHandle)]++_BilinearSampler ::+                 forall args . Fullfilled "_BilinearSampler(symbol)" args =>+                   String ->+                     ArgsHMap "_BilinearSampler(symbol)" args -> IO SymbolHandle+_BilinearSampler name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("grid",) <$> (args !? #grid :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BilinearSampler"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_BilinearSampler(symbol)" =+     '[]++_backward_BilinearSampler ::+                          forall args .+                            Fullfilled "_backward_BilinearSampler(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_BilinearSampler(symbol)" args ->+                                IO SymbolHandle+_backward_BilinearSampler name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BilinearSampler"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_ROIPooling(symbol)" =+     '[ '("pooled_size", AttrReq [Int]),+        '("spatial_scale", AttrReq Float), '("data", AttrOpt SymbolHandle),+        '("rois", AttrOpt SymbolHandle)]++_ROIPooling ::+            forall args . Fullfilled "_ROIPooling(symbol)" args =>+              String -> ArgsHMap "_ROIPooling(symbol)" args -> IO SymbolHandle+_ROIPooling name args+  = let scalarArgs+          = catMaybes+              [("pooled_size",) . showValue <$>+                 (args !? #pooled_size :: Maybe [Int]),+               ("spatial_scale",) . showValue <$>+                 (args !? #spatial_scale :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ROIPooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_ROIPooling(symbol)" = '[]++_backward_ROIPooling ::+                     forall args . Fullfilled "_backward_ROIPooling(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_ROIPooling(symbol)" args -> IO SymbolHandle+_backward_ROIPooling name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_ROIPooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SliceChannel(symbol)" = '[]++_backward_SliceChannel ::+                       forall args . Fullfilled "_backward_SliceChannel(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_SliceChannel(symbol)" args -> IO SymbolHandle+_backward_SliceChannel name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SliceChannel"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_CuDNNBatchNorm(symbol)" =+     '[]++_backward_CuDNNBatchNorm ::+                         forall args . Fullfilled "_backward_CuDNNBatchNorm(symbol)" args =>+                           String ->+                             ArgsHMap "_backward_CuDNNBatchNorm(symbol)" args -> IO SymbolHandle+_backward_CuDNNBatchNorm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_CuDNNBatchNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_FullyConnected(symbol)" =+     '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool),+        '("flatten", AttrOpt Bool), '("data", AttrOpt SymbolHandle),+        '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle)]++_FullyConnected ::+                forall args . Fullfilled "_FullyConnected(symbol)" args =>+                  String ->+                    ArgsHMap "_FullyConnected(symbol)" args -> IO SymbolHandle+_FullyConnected name args+  = let scalarArgs+          = catMaybes+              [("num_hidden",) . showValue <$>+                 (args !? #num_hidden :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "FullyConnected"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_FullyConnected(symbol)" =+     '[]++_backward_FullyConnected ::+                         forall args . Fullfilled "_backward_FullyConnected(symbol)" args =>+                           String ->+                             ArgsHMap "_backward_FullyConnected(symbol)" args -> IO SymbolHandle+_backward_FullyConnected name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_FullyConnected"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Convolution(symbol)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("cudnn_tune",+          AttrOpt+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+        '("cudnn_off", AttrOpt Bool),+        '("layout",+          AttrOpt+            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),+        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),+        '("bias", AttrOpt SymbolHandle)]++_Convolution ::+             forall args . Fullfilled "_Convolution(symbol)" args =>+               String -> ArgsHMap "_Convolution(symbol)" args -> IO SymbolHandle+_Convolution name args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Convolution"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Convolution(symbol)" = '[]++_backward_Convolution ::+                      forall args . Fullfilled "_backward_Convolution(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_Convolution(symbol)" args -> IO SymbolHandle+_backward_Convolution name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Convolution"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_L2Normalization(symbol)" =+     '[ '("eps", AttrOpt Float),+        '("mode", AttrOpt (EnumType '["channel", "instance", "spatial"])),+        '("data", AttrOpt SymbolHandle)]++_L2Normalization ::+                 forall args . Fullfilled "_L2Normalization(symbol)" args =>+                   String ->+                     ArgsHMap "_L2Normalization(symbol)" args -> IO SymbolHandle+_L2Normalization name args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["channel", "instance", "spatial"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "L2Normalization"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_L2Normalization(symbol)" =+     '[]++_backward_L2Normalization ::+                          forall args .+                            Fullfilled "_backward_L2Normalization(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_L2Normalization(symbol)" args ->+                                IO SymbolHandle+_backward_L2Normalization name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_L2Normalization"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Concat(symbol)" = '[]++_backward_Concat ::+                 forall args . Fullfilled "_backward_Concat(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_Concat(symbol)" args -> IO SymbolHandle+_backward_Concat name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Concat"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_RNN(symbol)" =+     '[ '("state_size", AttrReq Int), '("num_layers", AttrReq Int),+        '("bidirectional", AttrOpt Bool),+        '("mode",+          AttrReq (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),+        '("p", AttrOpt Float), '("state_outputs", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle),+        '("parameters", AttrOpt SymbolHandle),+        '("state", AttrOpt SymbolHandle),+        '("state_cell", AttrOpt SymbolHandle)]++_RNN ::+     forall args . Fullfilled "_RNN(symbol)" args =>+       String -> ArgsHMap "_RNN(symbol)" args -> IO SymbolHandle+_RNN name args+  = let scalarArgs+          = catMaybes+              [("state_size",) . showValue <$>+                 (args !? #state_size :: Maybe Int),+               ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int),+               ("bidirectional",) . showValue <$>+                 (args !? #bidirectional :: Maybe Bool),+               ("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),+               ("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("state_outputs",) . showValue <$>+                 (args !? #state_outputs :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("parameters",) <$> (args !? #parameters :: Maybe SymbolHandle),+               ("state",) <$> (args !? #state :: Maybe SymbolHandle),+               ("state_cell",) <$> (args !? #state_cell :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "RNN"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_RNN(symbol)" = '[]++_backward_RNN ::+              forall args . Fullfilled "_backward_RNN(symbol)" args =>+                String -> ArgsHMap "_backward_RNN(symbol)" args -> IO SymbolHandle+_backward_RNN name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_RNN"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_BatchNorm(symbol)" = '[]++_backward_BatchNorm ::+                    forall args . Fullfilled "_backward_BatchNorm(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_BatchNorm(symbol)" args -> IO SymbolHandle+_backward_BatchNorm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BatchNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Dropout(symbol)" =+     '[ '("p", AttrOpt Float),+        '("mode", AttrOpt (EnumType '["always", "training"])),+        '("data", AttrOpt SymbolHandle)]++_Dropout ::+         forall args . Fullfilled "_Dropout(symbol)" args =>+           String -> ArgsHMap "_Dropout(symbol)" args -> IO SymbolHandle+_Dropout name args+  = let scalarArgs+          = catMaybes+              [("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["always", "training"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Dropout"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Dropout(symbol)" = '[]++_backward_Dropout ::+                  forall args . Fullfilled "_backward_Dropout(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_Dropout(symbol)" args -> IO SymbolHandle+_backward_Dropout name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Dropout"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_CrossDeviceCopy(symbol)" = '[]++_CrossDeviceCopy ::+                 forall args . Fullfilled "_CrossDeviceCopy(symbol)" args =>+                   String ->+                     ArgsHMap "_CrossDeviceCopy(symbol)" args -> IO SymbolHandle+_CrossDeviceCopy name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_CrossDeviceCopy"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward__CrossDeviceCopy(symbol)" =+     '[]++_backward__CrossDeviceCopy ::+                           forall args .+                             Fullfilled "_backward__CrossDeviceCopy(symbol)" args =>+                             String ->+                               ArgsHMap "_backward__CrossDeviceCopy(symbol)" args ->+                                 IO SymbolHandle+_backward__CrossDeviceCopy name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__CrossDeviceCopy"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SoftmaxActivation(symbol)" =+     '[ '("mode", AttrOpt (EnumType '["channel", "instance"])),+        '("data", AttrOpt SymbolHandle)]++_SoftmaxActivation ::+                   forall args . Fullfilled "_SoftmaxActivation(symbol)" args =>+                     String ->+                       ArgsHMap "_SoftmaxActivation(symbol)" args -> IO SymbolHandle+_SoftmaxActivation name args+  = let scalarArgs+          = catMaybes+              [("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["channel", "instance"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SoftmaxActivation"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SoftmaxActivation(symbol)" =+     '[]++_backward_SoftmaxActivation ::+                            forall args .+                              Fullfilled "_backward_SoftmaxActivation(symbol)" args =>+                              String ->+                                ArgsHMap "_backward_SoftmaxActivation(symbol)" args ->+                                  IO SymbolHandle+_backward_SoftmaxActivation name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SoftmaxActivation"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_set_value(symbol)" =+     '[ '("src", AttrOpt Float)]++_set_value ::+           forall args . Fullfilled "_set_value(symbol)" args =>+             String -> ArgsHMap "_set_value(symbol)" args -> IO SymbolHandle+_set_value name args+  = let scalarArgs+          = catMaybes+              [("src",) . showValue <$> (args !? #src :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_set_value"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_imdecode(symbol)" =+     '[ '("index", AttrOpt Int), '("x0", AttrOpt Int),+        '("y0", AttrOpt Int), '("x1", AttrOpt Int), '("y1", AttrOpt Int),+        '("c", AttrOpt Int), '("size", AttrOpt Int),+        '("mean", AttrOpt SymbolHandle)]++_imdecode ::+          forall args . Fullfilled "_imdecode(symbol)" args =>+            String -> ArgsHMap "_imdecode(symbol)" args -> IO SymbolHandle+_imdecode name args+  = let scalarArgs+          = catMaybes+              [("index",) . showValue <$> (args !? #index :: Maybe Int),+               ("x0",) . showValue <$> (args !? #x0 :: Maybe Int),+               ("y0",) . showValue <$> (args !? #y0 :: Maybe Int),+               ("x1",) . showValue <$> (args !? #x1 :: Maybe Int),+               ("y1",) . showValue <$> (args !? #y1 :: Maybe Int),+               ("c",) . showValue <$> (args !? #c :: Maybe Int),+               ("size",) . showValue <$> (args !? #size :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("mean",) <$> (args !? #mean :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_imdecode"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym
+ ops/1.3/MXNet/Base/Operators/NDArray.hs view
@@ -0,0 +1,20011 @@+module MXNet.Base.Operators.NDArray where+import MXNet.Base.Raw+import MXNet.Base.Spec.Operator+import MXNet.Base.Spec.HMap+import Data.Maybe (catMaybes, fromMaybe)++type instance ParameterList "_sample_multinomial(ndarray)" =+     '[ '("shape", AttrOpt [Int]), '("get_prob", AttrOpt Bool),+        '("dtype",+          AttrOpt+            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),+        '("data", AttrOpt NDArrayHandle)]++_sample_multinomial ::+                    forall args . Fullfilled "_sample_multinomial(ndarray)" args =>+                      ArgsHMap "_sample_multinomial(ndarray)" args -> IO [NDArrayHandle]+_sample_multinomial args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_multinomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sample_multinomial_upd ::+                        forall args . Fullfilled "_sample_multinomial(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_sample_multinomial(ndarray)" args -> IO ()+_sample_multinomial_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_multinomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_sample_multinomial(ndarray)"+     = '[]++_backward_sample_multinomial ::+                             forall args .+                               Fullfilled "_backward_sample_multinomial(ndarray)" args =>+                               ArgsHMap "_backward_sample_multinomial(ndarray)" args ->+                                 IO [NDArrayHandle]+_backward_sample_multinomial args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sample_multinomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_sample_multinomial_upd ::+                                 forall args .+                                   Fullfilled "_backward_sample_multinomial(ndarray)" args =>+                                   [NDArrayHandle] ->+                                     ArgsHMap "_backward_sample_multinomial(ndarray)" args -> IO ()+_backward_sample_multinomial_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sample_multinomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_sample_uniform(ndarray)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("low", AttrOpt NDArrayHandle), '("high", AttrOpt NDArrayHandle)]++_sample_uniform ::+                forall args . Fullfilled "_sample_uniform(ndarray)" args =>+                  ArgsHMap "_sample_uniform(ndarray)" args -> IO [NDArrayHandle]+_sample_uniform args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("low",) <$> (args !? #low :: Maybe NDArrayHandle),+               ("high",) <$> (args !? #high :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_uniform"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sample_uniform_upd ::+                    forall args . Fullfilled "_sample_uniform(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_sample_uniform(ndarray)" args -> IO ()+_sample_uniform_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("low",) <$> (args !? #low :: Maybe NDArrayHandle),+               ("high",) <$> (args !? #high :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_uniform"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_sample_normal(ndarray)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("mu", AttrOpt NDArrayHandle), '("sigma", AttrOpt NDArrayHandle)]++_sample_normal ::+               forall args . Fullfilled "_sample_normal(ndarray)" args =>+                 ArgsHMap "_sample_normal(ndarray)" args -> IO [NDArrayHandle]+_sample_normal args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle),+               ("sigma",) <$> (args !? #sigma :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_normal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sample_normal_upd ::+                   forall args . Fullfilled "_sample_normal(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_sample_normal(ndarray)" args -> IO ()+_sample_normal_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle),+               ("sigma",) <$> (args !? #sigma :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_normal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_sample_gamma(ndarray)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("alpha", AttrOpt NDArrayHandle),+        '("beta", AttrOpt NDArrayHandle)]++_sample_gamma ::+              forall args . Fullfilled "_sample_gamma(ndarray)" args =>+                ArgsHMap "_sample_gamma(ndarray)" args -> IO [NDArrayHandle]+_sample_gamma args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_gamma"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sample_gamma_upd ::+                  forall args . Fullfilled "_sample_gamma(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_sample_gamma(ndarray)" args -> IO ()+_sample_gamma_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_gamma"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_sample_exponential(ndarray)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("lam", AttrOpt NDArrayHandle)]++_sample_exponential ::+                    forall args . Fullfilled "_sample_exponential(ndarray)" args =>+                      ArgsHMap "_sample_exponential(ndarray)" args -> IO [NDArrayHandle]+_sample_exponential args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_exponential"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sample_exponential_upd ::+                        forall args . Fullfilled "_sample_exponential(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_sample_exponential(ndarray)" args -> IO ()+_sample_exponential_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_exponential"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_sample_poisson(ndarray)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("lam", AttrOpt NDArrayHandle)]++_sample_poisson ::+                forall args . Fullfilled "_sample_poisson(ndarray)" args =>+                  ArgsHMap "_sample_poisson(ndarray)" args -> IO [NDArrayHandle]+_sample_poisson args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_poisson"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sample_poisson_upd ::+                    forall args . Fullfilled "_sample_poisson(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_sample_poisson(ndarray)" args -> IO ()+_sample_poisson_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_poisson"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_sample_negative_binomial(ndarray)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("k", AttrOpt NDArrayHandle), '("p", AttrOpt NDArrayHandle)]++_sample_negative_binomial ::+                          forall args .+                            Fullfilled "_sample_negative_binomial(ndarray)" args =>+                            ArgsHMap "_sample_negative_binomial(ndarray)" args ->+                              IO [NDArrayHandle]+_sample_negative_binomial args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("k",) <$> (args !? #k :: Maybe NDArrayHandle),+               ("p",) <$> (args !? #p :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_negative_binomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sample_negative_binomial_upd ::+                              forall args .+                                Fullfilled "_sample_negative_binomial(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_sample_negative_binomial(ndarray)" args -> IO ()+_sample_negative_binomial_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("k",) <$> (args !? #k :: Maybe NDArrayHandle),+               ("p",) <$> (args !? #p :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_negative_binomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_sample_generalized_negative_binomial(ndarray)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("mu", AttrOpt NDArrayHandle), '("alpha", AttrOpt NDArrayHandle)]++_sample_generalized_negative_binomial ::+                                      forall args .+                                        Fullfilled "_sample_generalized_negative_binomial(ndarray)"+                                          args =>+                                        ArgsHMap "_sample_generalized_negative_binomial(ndarray)"+                                          args+                                          -> IO [NDArrayHandle]+_sample_generalized_negative_binomial args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle),+               ("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_generalized_negative_binomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sample_generalized_negative_binomial_upd ::+                                          forall args .+                                            Fullfilled+                                              "_sample_generalized_negative_binomial(ndarray)"+                                              args =>+                                            [NDArrayHandle] ->+                                              ArgsHMap+                                                "_sample_generalized_negative_binomial(ndarray)"+                                                args+                                                -> IO ()+_sample_generalized_negative_binomial_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle),+               ("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_generalized_negative_binomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_sample_unique_zipfian(ndarray)" =+     '[ '("range_max", AttrReq Int), '("shape", AttrOpt [Int])]++_sample_unique_zipfian ::+                       forall args . Fullfilled "_sample_unique_zipfian(ndarray)" args =>+                         ArgsHMap "_sample_unique_zipfian(ndarray)" args ->+                           IO [NDArrayHandle]+_sample_unique_zipfian args+  = let scalarArgs+          = catMaybes+              [("range_max",) . showValue <$> (args !? #range_max :: Maybe Int),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_unique_zipfian"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sample_unique_zipfian_upd ::+                           forall args . Fullfilled "_sample_unique_zipfian(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_sample_unique_zipfian(ndarray)" args -> IO ()+_sample_unique_zipfian_upd outputs args+  = let scalarArgs+          = catMaybes+              [("range_max",) . showValue <$> (args !? #range_max :: Maybe Int),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_unique_zipfian"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_uniform(ndarray)" =+     '[ '("low", AttrOpt Float), '("high", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_uniform ::+                forall args . Fullfilled "_random_uniform(ndarray)" args =>+                  ArgsHMap "_random_uniform(ndarray)" args -> IO [NDArrayHandle]+_random_uniform args+  = let scalarArgs+          = catMaybes+              [("low",) . showValue <$> (args !? #low :: Maybe Float),+               ("high",) . showValue <$> (args !? #high :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_uniform"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_uniform_upd ::+                    forall args . Fullfilled "_random_uniform(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_random_uniform(ndarray)" args -> IO ()+_random_uniform_upd outputs args+  = let scalarArgs+          = catMaybes+              [("low",) . showValue <$> (args !? #low :: Maybe Float),+               ("high",) . showValue <$> (args !? #high :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_uniform"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_normal(ndarray)" =+     '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_normal ::+               forall args . Fullfilled "_random_normal(ndarray)" args =>+                 ArgsHMap "_random_normal(ndarray)" args -> IO [NDArrayHandle]+_random_normal args+  = let scalarArgs+          = catMaybes+              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),+               ("scale",) . showValue <$> (args !? #scale :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_normal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_normal_upd ::+                   forall args . Fullfilled "_random_normal(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_random_normal(ndarray)" args -> IO ()+_random_normal_upd outputs args+  = let scalarArgs+          = catMaybes+              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),+               ("scale",) . showValue <$> (args !? #scale :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_normal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_gamma(ndarray)" =+     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_gamma ::+              forall args . Fullfilled "_random_gamma(ndarray)" args =>+                ArgsHMap "_random_gamma(ndarray)" args -> IO [NDArrayHandle]+_random_gamma args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_gamma"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_gamma_upd ::+                  forall args . Fullfilled "_random_gamma(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_random_gamma(ndarray)" args -> IO ()+_random_gamma_upd outputs args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_gamma"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_exponential(ndarray)" =+     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),+        '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_exponential ::+                    forall args . Fullfilled "_random_exponential(ndarray)" args =>+                      ArgsHMap "_random_exponential(ndarray)" args -> IO [NDArrayHandle]+_random_exponential args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_exponential"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_exponential_upd ::+                        forall args . Fullfilled "_random_exponential(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_random_exponential(ndarray)" args -> IO ()+_random_exponential_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_exponential"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_poisson(ndarray)" =+     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),+        '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_poisson ::+                forall args . Fullfilled "_random_poisson(ndarray)" args =>+                  ArgsHMap "_random_poisson(ndarray)" args -> IO [NDArrayHandle]+_random_poisson args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_poisson"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_poisson_upd ::+                    forall args . Fullfilled "_random_poisson(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_random_poisson(ndarray)" args -> IO ()+_random_poisson_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_poisson"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_negative_binomial(ndarray)" =+     '[ '("k", AttrOpt Int), '("p", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_negative_binomial ::+                          forall args .+                            Fullfilled "_random_negative_binomial(ndarray)" args =>+                            ArgsHMap "_random_negative_binomial(ndarray)" args ->+                              IO [NDArrayHandle]+_random_negative_binomial args+  = let scalarArgs+          = catMaybes+              [("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_negative_binomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_negative_binomial_upd ::+                              forall args .+                                Fullfilled "_random_negative_binomial(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_random_negative_binomial(ndarray)" args -> IO ()+_random_negative_binomial_upd outputs args+  = let scalarArgs+          = catMaybes+              [("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_negative_binomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_random_generalized_negative_binomial(ndarray)" =+     '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_generalized_negative_binomial ::+                                      forall args .+                                        Fullfilled "_random_generalized_negative_binomial(ndarray)"+                                          args =>+                                        ArgsHMap "_random_generalized_negative_binomial(ndarray)"+                                          args+                                          -> IO [NDArrayHandle]+_random_generalized_negative_binomial args+  = let scalarArgs+          = catMaybes+              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_generalized_negative_binomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_generalized_negative_binomial_upd ::+                                          forall args .+                                            Fullfilled+                                              "_random_generalized_negative_binomial(ndarray)"+                                              args =>+                                            [NDArrayHandle] ->+                                              ArgsHMap+                                                "_random_generalized_negative_binomial(ndarray)"+                                                args+                                                -> IO ()+_random_generalized_negative_binomial_upd outputs args+  = let scalarArgs+          = catMaybes+              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_generalized_negative_binomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_shuffle(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_shuffle ::+         forall args . Fullfilled "_shuffle(ndarray)" args =>+           ArgsHMap "_shuffle(ndarray)" args -> IO [NDArrayHandle]+_shuffle args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_shuffle"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_shuffle_upd ::+             forall args . Fullfilled "_shuffle(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "_shuffle(ndarray)" args -> IO ()+_shuffle_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_shuffle"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Custom(ndarray)" = '[]++_backward_Custom ::+                 forall args . Fullfilled "_backward_Custom(ndarray)" args =>+                   ArgsHMap "_backward_Custom(ndarray)" args -> IO [NDArrayHandle]+_backward_Custom args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Custom"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Custom_upd ::+                     forall args . Fullfilled "_backward_Custom(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_backward_Custom(ndarray)" args -> IO ()+_backward_Custom_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Custom"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_power(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_power ::+                forall args . Fullfilled "broadcast_power(ndarray)" args =>+                  ArgsHMap "broadcast_power(ndarray)" args -> IO [NDArrayHandle]+broadcast_power args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_power"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_power_upd ::+                    forall args . Fullfilled "broadcast_power(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "broadcast_power(ndarray)" args -> IO ()+broadcast_power_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_power"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_broadcast_power(ndarray)" =+     '[]++_backward_broadcast_power ::+                          forall args .+                            Fullfilled "_backward_broadcast_power(ndarray)" args =>+                            ArgsHMap "_backward_broadcast_power(ndarray)" args ->+                              IO [NDArrayHandle]+_backward_broadcast_power args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_power"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_broadcast_power_upd ::+                              forall args .+                                Fullfilled "_backward_broadcast_power(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_backward_broadcast_power(ndarray)" args -> IO ()+_backward_broadcast_power_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_power"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_maximum(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_maximum ::+                  forall args . Fullfilled "broadcast_maximum(ndarray)" args =>+                    ArgsHMap "broadcast_maximum(ndarray)" args -> IO [NDArrayHandle]+broadcast_maximum args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_maximum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_maximum_upd ::+                      forall args . Fullfilled "broadcast_maximum(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "broadcast_maximum(ndarray)" args -> IO ()+broadcast_maximum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_maximum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_broadcast_maximum(ndarray)"+     = '[]++_backward_broadcast_maximum ::+                            forall args .+                              Fullfilled "_backward_broadcast_maximum(ndarray)" args =>+                              ArgsHMap "_backward_broadcast_maximum(ndarray)" args ->+                                IO [NDArrayHandle]+_backward_broadcast_maximum args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_maximum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_broadcast_maximum_upd ::+                                forall args .+                                  Fullfilled "_backward_broadcast_maximum(ndarray)" args =>+                                  [NDArrayHandle] ->+                                    ArgsHMap "_backward_broadcast_maximum(ndarray)" args -> IO ()+_backward_broadcast_maximum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_maximum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_minimum(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_minimum ::+                  forall args . Fullfilled "broadcast_minimum(ndarray)" args =>+                    ArgsHMap "broadcast_minimum(ndarray)" args -> IO [NDArrayHandle]+broadcast_minimum args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_minimum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_minimum_upd ::+                      forall args . Fullfilled "broadcast_minimum(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "broadcast_minimum(ndarray)" args -> IO ()+broadcast_minimum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_minimum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_broadcast_minimum(ndarray)"+     = '[]++_backward_broadcast_minimum ::+                            forall args .+                              Fullfilled "_backward_broadcast_minimum(ndarray)" args =>+                              ArgsHMap "_backward_broadcast_minimum(ndarray)" args ->+                                IO [NDArrayHandle]+_backward_broadcast_minimum args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_minimum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_broadcast_minimum_upd ::+                                forall args .+                                  Fullfilled "_backward_broadcast_minimum(ndarray)" args =>+                                  [NDArrayHandle] ->+                                    ArgsHMap "_backward_broadcast_minimum(ndarray)" args -> IO ()+_backward_broadcast_minimum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_minimum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_hypot(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_hypot ::+                forall args . Fullfilled "broadcast_hypot(ndarray)" args =>+                  ArgsHMap "broadcast_hypot(ndarray)" args -> IO [NDArrayHandle]+broadcast_hypot args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_hypot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_hypot_upd ::+                    forall args . Fullfilled "broadcast_hypot(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "broadcast_hypot(ndarray)" args -> IO ()+broadcast_hypot_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_hypot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_broadcast_hypot(ndarray)" =+     '[]++_backward_broadcast_hypot ::+                          forall args .+                            Fullfilled "_backward_broadcast_hypot(ndarray)" args =>+                            ArgsHMap "_backward_broadcast_hypot(ndarray)" args ->+                              IO [NDArrayHandle]+_backward_broadcast_hypot args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_hypot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_broadcast_hypot_upd ::+                              forall args .+                                Fullfilled "_backward_broadcast_hypot(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_backward_broadcast_hypot(ndarray)" args -> IO ()+_backward_broadcast_hypot_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_hypot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_equal(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_equal ::+       forall args . Fullfilled "_equal(ndarray)" args =>+         ArgsHMap "_equal(ndarray)" args -> IO [NDArrayHandle]+_equal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_equal_upd ::+           forall args . Fullfilled "_equal(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "_equal(ndarray)" args -> IO ()+_equal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_not_equal(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_not_equal ::+           forall args . Fullfilled "_not_equal(ndarray)" args =>+             ArgsHMap "_not_equal(ndarray)" args -> IO [NDArrayHandle]+_not_equal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_not_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_not_equal_upd ::+               forall args . Fullfilled "_not_equal(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "_not_equal(ndarray)" args -> IO ()+_not_equal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_not_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_greater(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_greater ::+         forall args . Fullfilled "_greater(ndarray)" args =>+           ArgsHMap "_greater(ndarray)" args -> IO [NDArrayHandle]+_greater args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_greater_upd ::+             forall args . Fullfilled "_greater(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "_greater(ndarray)" args -> IO ()+_greater_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_greater_equal(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_greater_equal ::+               forall args . Fullfilled "_greater_equal(ndarray)" args =>+                 ArgsHMap "_greater_equal(ndarray)" args -> IO [NDArrayHandle]+_greater_equal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_greater_equal_upd ::+                   forall args . Fullfilled "_greater_equal(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_greater_equal(ndarray)" args -> IO ()+_greater_equal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_lesser(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_lesser ::+        forall args . Fullfilled "_lesser(ndarray)" args =>+          ArgsHMap "_lesser(ndarray)" args -> IO [NDArrayHandle]+_lesser args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_lesser_upd ::+            forall args . Fullfilled "_lesser(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "_lesser(ndarray)" args -> IO ()+_lesser_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_lesser_equal(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_lesser_equal ::+              forall args . Fullfilled "_lesser_equal(ndarray)" args =>+                ArgsHMap "_lesser_equal(ndarray)" args -> IO [NDArrayHandle]+_lesser_equal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_lesser_equal_upd ::+                  forall args . Fullfilled "_lesser_equal(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_lesser_equal(ndarray)" args -> IO ()+_lesser_equal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_logical_and(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_logical_and ::+             forall args . Fullfilled "_logical_and(ndarray)" args =>+               ArgsHMap "_logical_and(ndarray)" args -> IO [NDArrayHandle]+_logical_and args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_and"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_logical_and_upd ::+                 forall args . Fullfilled "_logical_and(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_logical_and(ndarray)" args -> IO ()+_logical_and_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_and"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_logical_or(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_logical_or ::+            forall args . Fullfilled "_logical_or(ndarray)" args =>+              ArgsHMap "_logical_or(ndarray)" args -> IO [NDArrayHandle]+_logical_or args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_or"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_logical_or_upd ::+                forall args . Fullfilled "_logical_or(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_logical_or(ndarray)" args -> IO ()+_logical_or_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_or"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_logical_xor(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_logical_xor ::+             forall args . Fullfilled "_logical_xor(ndarray)" args =>+               ArgsHMap "_logical_xor(ndarray)" args -> IO [NDArrayHandle]+_logical_xor args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_xor"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_logical_xor_upd ::+                 forall args . Fullfilled "_logical_xor(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_logical_xor(ndarray)" args -> IO ()+_logical_xor_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_xor"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_power(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_power ::+       forall args . Fullfilled "_power(ndarray)" args =>+         ArgsHMap "_power(ndarray)" args -> IO [NDArrayHandle]+_power args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_power"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_power_upd ::+           forall args . Fullfilled "_power(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "_power(ndarray)" args -> IO ()+_power_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_power"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_power(ndarray)" = '[]++_backward_power ::+                forall args . Fullfilled "_backward_power(ndarray)" args =>+                  ArgsHMap "_backward_power(ndarray)" args -> IO [NDArrayHandle]+_backward_power args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_power"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_power_upd ::+                    forall args . Fullfilled "_backward_power(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_power(ndarray)" args -> IO ()+_backward_power_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_power"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_maximum(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_maximum ::+         forall args . Fullfilled "_maximum(ndarray)" args =>+           ArgsHMap "_maximum(ndarray)" args -> IO [NDArrayHandle]+_maximum args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_maximum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_maximum_upd ::+             forall args . Fullfilled "_maximum(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "_maximum(ndarray)" args -> IO ()+_maximum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_maximum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_maximum(ndarray)" = '[]++_backward_maximum ::+                  forall args . Fullfilled "_backward_maximum(ndarray)" args =>+                    ArgsHMap "_backward_maximum(ndarray)" args -> IO [NDArrayHandle]+_backward_maximum args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_maximum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_maximum_upd ::+                      forall args . Fullfilled "_backward_maximum(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_maximum(ndarray)" args -> IO ()+_backward_maximum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_maximum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_minimum(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_minimum ::+         forall args . Fullfilled "_minimum(ndarray)" args =>+           ArgsHMap "_minimum(ndarray)" args -> IO [NDArrayHandle]+_minimum args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minimum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_minimum_upd ::+             forall args . Fullfilled "_minimum(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "_minimum(ndarray)" args -> IO ()+_minimum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minimum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_minimum(ndarray)" = '[]++_backward_minimum ::+                  forall args . Fullfilled "_backward_minimum(ndarray)" args =>+                    ArgsHMap "_backward_minimum(ndarray)" args -> IO [NDArrayHandle]+_backward_minimum args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_minimum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_minimum_upd ::+                      forall args . Fullfilled "_backward_minimum(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_minimum(ndarray)" args -> IO ()+_backward_minimum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_minimum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_hypot(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_hypot ::+       forall args . Fullfilled "_hypot(ndarray)" args =>+         ArgsHMap "_hypot(ndarray)" args -> IO [NDArrayHandle]+_hypot args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_hypot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_hypot_upd ::+           forall args . Fullfilled "_hypot(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "_hypot(ndarray)" args -> IO ()+_hypot_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_hypot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_hypot(ndarray)" = '[]++_backward_hypot ::+                forall args . Fullfilled "_backward_hypot(ndarray)" args =>+                  ArgsHMap "_backward_hypot(ndarray)" args -> IO [NDArrayHandle]+_backward_hypot args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_hypot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_hypot_upd ::+                    forall args . Fullfilled "_backward_hypot(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_hypot(ndarray)" args -> IO ()+_backward_hypot_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_hypot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_square_sum(ndarray)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++_square_sum ::+            forall args . Fullfilled "_square_sum(ndarray)" args =>+              ArgsHMap "_square_sum(ndarray)" args -> IO [NDArrayHandle]+_square_sum args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_square_sum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_square_sum_upd ::+                forall args . Fullfilled "_square_sum(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_square_sum(ndarray)" args -> IO ()+_square_sum_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_square_sum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_square_sum(ndarray)" = '[]++_backward_square_sum ::+                     forall args . Fullfilled "_backward_square_sum(ndarray)" args =>+                       ArgsHMap "_backward_square_sum(ndarray)" args -> IO [NDArrayHandle]+_backward_square_sum args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_square_sum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_square_sum_upd ::+                         forall args . Fullfilled "_backward_square_sum(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_square_sum(ndarray)" args -> IO ()+_backward_square_sum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_square_sum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "add_n(ndarray)" =+     '[ '("args", AttrOpt [NDArrayHandle])]++add_n ::+      forall args . Fullfilled "add_n(ndarray)" args =>+        ArgsHMap "add_n(ndarray)" args -> IO [NDArrayHandle]+add_n args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "add_n"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        Nothing+         return listndarr++add_n_upd ::+          forall args . Fullfilled "add_n(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "add_n(ndarray)" args -> IO ()+add_n_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "add_n"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        (Just outputs)+         return ()++type instance ParameterList "_zeros(ndarray)" =+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"]))]++_zeros ::+       forall args . Fullfilled "_zeros(ndarray)" args =>+         ArgsHMap "_zeros(ndarray)" args -> IO [NDArrayHandle]+_zeros args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_zeros"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_zeros_upd ::+           forall args . Fullfilled "_zeros(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "_zeros(ndarray)" args -> IO ()+_zeros_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_zeros"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_eye(ndarray)" =+     '[ '("_N", AttrReq Int), '("_M", AttrOpt Int), '("k", AttrOpt Int),+        '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"]))]++_eye ::+     forall args . Fullfilled "_eye(ndarray)" args =>+       ArgsHMap "_eye(ndarray)" args -> IO [NDArrayHandle]+_eye args+  = let scalarArgs+          = catMaybes+              [("_N",) . showValue <$> (args !? #_N :: Maybe Int),+               ("_M",) . showValue <$> (args !? #_M :: Maybe Int),+               ("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_eye"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_eye_upd ::+         forall args . Fullfilled "_eye(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "_eye(ndarray)" args -> IO ()+_eye_upd outputs args+  = let scalarArgs+          = catMaybes+              [("_N",) . showValue <$> (args !? #_N :: Maybe Int),+               ("_M",) . showValue <$> (args !? #_M :: Maybe Int),+               ("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_eye"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_ones(ndarray)" =+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"]))]++_ones ::+      forall args . Fullfilled "_ones(ndarray)" args =>+        ArgsHMap "_ones(ndarray)" args -> IO [NDArrayHandle]+_ones args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_ones"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_ones_upd ::+          forall args . Fullfilled "_ones(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "_ones(ndarray)" args -> IO ()+_ones_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_ones"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_full(ndarray)" =+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("value", AttrReq Double)]++_full ::+      forall args . Fullfilled "_full(ndarray)" args =>+        ArgsHMap "_full(ndarray)" args -> IO [NDArrayHandle]+_full args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"])),+               ("value",) . showValue <$> (args !? #value :: Maybe Double)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_full"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_full_upd ::+          forall args . Fullfilled "_full(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "_full(ndarray)" args -> IO ()+_full_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"])),+               ("value",) . showValue <$> (args !? #value :: Maybe Double)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_full"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_arange(ndarray)" =+     '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)),+        '("step", AttrOpt Double), '("repeat", AttrOpt Int),+        '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"]))]++_arange ::+        forall args . Fullfilled "_arange(ndarray)" args =>+          ArgsHMap "_arange(ndarray)" args -> IO [NDArrayHandle]+_arange args+  = let scalarArgs+          = catMaybes+              [("start",) . showValue <$> (args !? #start :: Maybe Double),+               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),+               ("step",) . showValue <$> (args !? #step :: Maybe Double),+               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_arange"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_arange_upd ::+            forall args . Fullfilled "_arange(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "_arange(ndarray)" args -> IO ()+_arange_upd outputs args+  = let scalarArgs+          = catMaybes+              [("start",) . showValue <$> (args !? #start :: Maybe Double),+               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),+               ("step",) . showValue <$> (args !? #step :: Maybe Double),+               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_arange"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "zeros_like(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++zeros_like ::+           forall args . Fullfilled "zeros_like(ndarray)" args =>+             ArgsHMap "zeros_like(ndarray)" args -> IO [NDArrayHandle]+zeros_like args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "zeros_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++zeros_like_upd ::+               forall args . Fullfilled "zeros_like(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "zeros_like(ndarray)" args -> IO ()+zeros_like_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "zeros_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "ones_like(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++ones_like ::+          forall args . Fullfilled "ones_like(ndarray)" args =>+            ArgsHMap "ones_like(ndarray)" args -> IO [NDArrayHandle]+ones_like args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ones_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++ones_like_upd ::+              forall args . Fullfilled "ones_like(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "ones_like(ndarray)" args -> IO ()+ones_like_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ones_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_add(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_add ::+              forall args . Fullfilled "broadcast_add(ndarray)" args =>+                ArgsHMap "broadcast_add(ndarray)" args -> IO [NDArrayHandle]+broadcast_add args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_add_upd ::+                  forall args . Fullfilled "broadcast_add(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "broadcast_add(ndarray)" args -> IO ()+broadcast_add_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_broadcast_add(ndarray)" =+     '[]++_backward_broadcast_add ::+                        forall args . Fullfilled "_backward_broadcast_add(ndarray)" args =>+                          ArgsHMap "_backward_broadcast_add(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_broadcast_add args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_broadcast_add_upd ::+                            forall args . Fullfilled "_backward_broadcast_add(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_broadcast_add(ndarray)" args -> IO ()+_backward_broadcast_add_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_sub(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_sub ::+              forall args . Fullfilled "broadcast_sub(ndarray)" args =>+                ArgsHMap "broadcast_sub(ndarray)" args -> IO [NDArrayHandle]+broadcast_sub args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_sub"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_sub_upd ::+                  forall args . Fullfilled "broadcast_sub(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "broadcast_sub(ndarray)" args -> IO ()+broadcast_sub_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_sub"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_broadcast_sub(ndarray)" =+     '[]++_backward_broadcast_sub ::+                        forall args . Fullfilled "_backward_broadcast_sub(ndarray)" args =>+                          ArgsHMap "_backward_broadcast_sub(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_broadcast_sub args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_sub"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_broadcast_sub_upd ::+                            forall args . Fullfilled "_backward_broadcast_sub(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_broadcast_sub(ndarray)" args -> IO ()+_backward_broadcast_sub_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_sub"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_mul(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_mul ::+              forall args . Fullfilled "broadcast_mul(ndarray)" args =>+                ArgsHMap "broadcast_mul(ndarray)" args -> IO [NDArrayHandle]+broadcast_mul args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_mul"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_mul_upd ::+                  forall args . Fullfilled "broadcast_mul(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "broadcast_mul(ndarray)" args -> IO ()+broadcast_mul_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_mul"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_broadcast_mul(ndarray)" =+     '[]++_backward_broadcast_mul ::+                        forall args . Fullfilled "_backward_broadcast_mul(ndarray)" args =>+                          ArgsHMap "_backward_broadcast_mul(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_broadcast_mul args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_mul"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_broadcast_mul_upd ::+                            forall args . Fullfilled "_backward_broadcast_mul(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_broadcast_mul(ndarray)" args -> IO ()+_backward_broadcast_mul_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_mul"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_div(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_div ::+              forall args . Fullfilled "broadcast_div(ndarray)" args =>+                ArgsHMap "broadcast_div(ndarray)" args -> IO [NDArrayHandle]+broadcast_div args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_div_upd ::+                  forall args . Fullfilled "broadcast_div(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "broadcast_div(ndarray)" args -> IO ()+broadcast_div_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_broadcast_div(ndarray)" =+     '[]++_backward_broadcast_div ::+                        forall args . Fullfilled "_backward_broadcast_div(ndarray)" args =>+                          ArgsHMap "_backward_broadcast_div(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_broadcast_div args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_broadcast_div_upd ::+                            forall args . Fullfilled "_backward_broadcast_div(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_broadcast_div(ndarray)" args -> IO ()+_backward_broadcast_div_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_mod(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_mod ::+              forall args . Fullfilled "broadcast_mod(ndarray)" args =>+                ArgsHMap "broadcast_mod(ndarray)" args -> IO [NDArrayHandle]+broadcast_mod args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_mod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_mod_upd ::+                  forall args . Fullfilled "broadcast_mod(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "broadcast_mod(ndarray)" args -> IO ()+broadcast_mod_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_mod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_broadcast_mod(ndarray)" =+     '[]++_backward_broadcast_mod ::+                        forall args . Fullfilled "_backward_broadcast_mod(ndarray)" args =>+                          ArgsHMap "_backward_broadcast_mod(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_broadcast_mod args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_mod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_broadcast_mod_upd ::+                            forall args . Fullfilled "_backward_broadcast_mod(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_broadcast_mod(ndarray)" args -> IO ()+_backward_broadcast_mod_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_mod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_gemm(ndarray)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("alpha", AttrOpt Double), '("beta", AttrOpt Double),+        '("axis", AttrOpt Int), '("_A", AttrOpt NDArrayHandle),+        '("_B", AttrOpt NDArrayHandle), '("_C", AttrOpt NDArrayHandle)]++_linalg_gemm ::+             forall args . Fullfilled "_linalg_gemm(ndarray)" args =>+               ArgsHMap "_linalg_gemm(ndarray)" args -> IO [NDArrayHandle]+_linalg_gemm args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Double),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),+               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle),+               ("_C",) <$> (args !? #_C :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gemm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_gemm_upd ::+                 forall args . Fullfilled "_linalg_gemm(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_linalg_gemm(ndarray)" args -> IO ()+_linalg_gemm_upd outputs args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Double),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),+               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle),+               ("_C",) <$> (args !? #_C :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gemm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_gemm(ndarray)" = '[]++_backward_linalg_gemm ::+                      forall args . Fullfilled "_backward_linalg_gemm(ndarray)" args =>+                        ArgsHMap "_backward_linalg_gemm(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_linalg_gemm args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gemm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_gemm_upd ::+                          forall args . Fullfilled "_backward_linalg_gemm(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_linalg_gemm(ndarray)" args -> IO ()+_backward_linalg_gemm_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gemm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_gemm2(ndarray)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("alpha", AttrOpt Double), '("axis", AttrOpt Int),+        '("_A", AttrOpt NDArrayHandle), '("_B", AttrOpt NDArrayHandle)]++_linalg_gemm2 ::+              forall args . Fullfilled "_linalg_gemm2(ndarray)" args =>+                ArgsHMap "_linalg_gemm2(ndarray)" args -> IO [NDArrayHandle]+_linalg_gemm2 args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),+               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gemm2"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_gemm2_upd ::+                  forall args . Fullfilled "_linalg_gemm2(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_linalg_gemm2(ndarray)" args -> IO ()+_linalg_gemm2_upd outputs args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),+               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gemm2"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_gemm2(ndarray)" = '[]++_backward_linalg_gemm2 ::+                       forall args . Fullfilled "_backward_linalg_gemm2(ndarray)" args =>+                         ArgsHMap "_backward_linalg_gemm2(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_linalg_gemm2 args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gemm2"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_gemm2_upd ::+                           forall args . Fullfilled "_backward_linalg_gemm2(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_linalg_gemm2(ndarray)" args -> IO ()+_backward_linalg_gemm2_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gemm2"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_potrf(ndarray)" =+     '[ '("_A", AttrOpt NDArrayHandle)]++_linalg_potrf ::+              forall args . Fullfilled "_linalg_potrf(ndarray)" args =>+                ArgsHMap "_linalg_potrf(ndarray)" args -> IO [NDArrayHandle]+_linalg_potrf args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_potrf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_potrf_upd ::+                  forall args . Fullfilled "_linalg_potrf(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_linalg_potrf(ndarray)" args -> IO ()+_linalg_potrf_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_potrf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_potrf(ndarray)" = '[]++_backward_linalg_potrf ::+                       forall args . Fullfilled "_backward_linalg_potrf(ndarray)" args =>+                         ArgsHMap "_backward_linalg_potrf(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_linalg_potrf args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_potrf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_potrf_upd ::+                           forall args . Fullfilled "_backward_linalg_potrf(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_linalg_potrf(ndarray)" args -> IO ()+_backward_linalg_potrf_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_potrf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_potri(ndarray)" =+     '[ '("_A", AttrOpt NDArrayHandle)]++_linalg_potri ::+              forall args . Fullfilled "_linalg_potri(ndarray)" args =>+                ArgsHMap "_linalg_potri(ndarray)" args -> IO [NDArrayHandle]+_linalg_potri args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_potri"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_potri_upd ::+                  forall args . Fullfilled "_linalg_potri(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_linalg_potri(ndarray)" args -> IO ()+_linalg_potri_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_potri"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_potri(ndarray)" = '[]++_backward_linalg_potri ::+                       forall args . Fullfilled "_backward_linalg_potri(ndarray)" args =>+                         ArgsHMap "_backward_linalg_potri(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_linalg_potri args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_potri"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_potri_upd ::+                           forall args . Fullfilled "_backward_linalg_potri(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_linalg_potri(ndarray)" args -> IO ()+_backward_linalg_potri_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_potri"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_trmm(ndarray)" =+     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),+        '("alpha", AttrOpt Double), '("_A", AttrOpt NDArrayHandle),+        '("_B", AttrOpt NDArrayHandle)]++_linalg_trmm ::+             forall args . Fullfilled "_linalg_trmm(ndarray)" args =>+               ArgsHMap "_linalg_trmm(ndarray)" args -> IO [NDArrayHandle]+_linalg_trmm args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),+               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_trmm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_trmm_upd ::+                 forall args . Fullfilled "_linalg_trmm(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_linalg_trmm(ndarray)" args -> IO ()+_linalg_trmm_upd outputs args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),+               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_trmm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_trmm(ndarray)" = '[]++_backward_linalg_trmm ::+                      forall args . Fullfilled "_backward_linalg_trmm(ndarray)" args =>+                        ArgsHMap "_backward_linalg_trmm(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_linalg_trmm args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_trmm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_trmm_upd ::+                          forall args . Fullfilled "_backward_linalg_trmm(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_linalg_trmm(ndarray)" args -> IO ()+_backward_linalg_trmm_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_trmm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_trsm(ndarray)" =+     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),+        '("alpha", AttrOpt Double), '("_A", AttrOpt NDArrayHandle),+        '("_B", AttrOpt NDArrayHandle)]++_linalg_trsm ::+             forall args . Fullfilled "_linalg_trsm(ndarray)" args =>+               ArgsHMap "_linalg_trsm(ndarray)" args -> IO [NDArrayHandle]+_linalg_trsm args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),+               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_trsm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_trsm_upd ::+                 forall args . Fullfilled "_linalg_trsm(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_linalg_trsm(ndarray)" args -> IO ()+_linalg_trsm_upd outputs args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),+               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_trsm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_trsm(ndarray)" = '[]++_backward_linalg_trsm ::+                      forall args . Fullfilled "_backward_linalg_trsm(ndarray)" args =>+                        ArgsHMap "_backward_linalg_trsm(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_linalg_trsm args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_trsm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_trsm_upd ::+                          forall args . Fullfilled "_backward_linalg_trsm(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_linalg_trsm(ndarray)" args -> IO ()+_backward_linalg_trsm_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_trsm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_sumlogdiag(ndarray)" =+     '[ '("_A", AttrOpt NDArrayHandle)]++_linalg_sumlogdiag ::+                   forall args . Fullfilled "_linalg_sumlogdiag(ndarray)" args =>+                     ArgsHMap "_linalg_sumlogdiag(ndarray)" args -> IO [NDArrayHandle]+_linalg_sumlogdiag args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_sumlogdiag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_sumlogdiag_upd ::+                       forall args . Fullfilled "_linalg_sumlogdiag(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_linalg_sumlogdiag(ndarray)" args -> IO ()+_linalg_sumlogdiag_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_sumlogdiag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_sumlogdiag(ndarray)"+     = '[]++_backward_linalg_sumlogdiag ::+                            forall args .+                              Fullfilled "_backward_linalg_sumlogdiag(ndarray)" args =>+                              ArgsHMap "_backward_linalg_sumlogdiag(ndarray)" args ->+                                IO [NDArrayHandle]+_backward_linalg_sumlogdiag args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_sumlogdiag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_sumlogdiag_upd ::+                                forall args .+                                  Fullfilled "_backward_linalg_sumlogdiag(ndarray)" args =>+                                  [NDArrayHandle] ->+                                    ArgsHMap "_backward_linalg_sumlogdiag(ndarray)" args -> IO ()+_backward_linalg_sumlogdiag_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_sumlogdiag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_syrk(ndarray)" =+     '[ '("transpose", AttrOpt Bool), '("alpha", AttrOpt Double),+        '("_A", AttrOpt NDArrayHandle)]++_linalg_syrk ::+             forall args . Fullfilled "_linalg_syrk(ndarray)" args =>+               ArgsHMap "_linalg_syrk(ndarray)" args -> IO [NDArrayHandle]+_linalg_syrk args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_syrk"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_syrk_upd ::+                 forall args . Fullfilled "_linalg_syrk(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_linalg_syrk(ndarray)" args -> IO ()+_linalg_syrk_upd outputs args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_syrk"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_syrk(ndarray)" = '[]++_backward_linalg_syrk ::+                      forall args . Fullfilled "_backward_linalg_syrk(ndarray)" args =>+                        ArgsHMap "_backward_linalg_syrk(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_linalg_syrk args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_syrk"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_syrk_upd ::+                          forall args . Fullfilled "_backward_linalg_syrk(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_linalg_syrk(ndarray)" args -> IO ()+_backward_linalg_syrk_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_syrk"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_gelqf(ndarray)" =+     '[ '("_A", AttrOpt NDArrayHandle)]++_linalg_gelqf ::+              forall args . Fullfilled "_linalg_gelqf(ndarray)" args =>+                ArgsHMap "_linalg_gelqf(ndarray)" args -> IO [NDArrayHandle]+_linalg_gelqf args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gelqf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_gelqf_upd ::+                  forall args . Fullfilled "_linalg_gelqf(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_linalg_gelqf(ndarray)" args -> IO ()+_linalg_gelqf_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gelqf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_gelqf(ndarray)" = '[]++_backward_linalg_gelqf ::+                       forall args . Fullfilled "_backward_linalg_gelqf(ndarray)" args =>+                         ArgsHMap "_backward_linalg_gelqf(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_linalg_gelqf args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gelqf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_gelqf_upd ::+                           forall args . Fullfilled "_backward_linalg_gelqf(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_linalg_gelqf(ndarray)" args -> IO ()+_backward_linalg_gelqf_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gelqf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_syevd(ndarray)" =+     '[ '("_A", AttrOpt NDArrayHandle)]++_linalg_syevd ::+              forall args . Fullfilled "_linalg_syevd(ndarray)" args =>+                ArgsHMap "_linalg_syevd(ndarray)" args -> IO [NDArrayHandle]+_linalg_syevd args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_syevd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_syevd_upd ::+                  forall args . Fullfilled "_linalg_syevd(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_linalg_syevd(ndarray)" args -> IO ()+_linalg_syevd_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_syevd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_syevd(ndarray)" = '[]++_backward_linalg_syevd ::+                       forall args . Fullfilled "_backward_linalg_syevd(ndarray)" args =>+                         ArgsHMap "_backward_linalg_syevd(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_linalg_syevd args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_syevd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_syevd_upd ::+                           forall args . Fullfilled "_backward_linalg_syevd(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_linalg_syevd(ndarray)" args -> IO ()+_backward_linalg_syevd_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_syevd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_histogram(ndarray)" =+     '[ '("bin_cnt", AttrOpt (Maybe Int)), '("range", AttrOpt Int),+        '("data", AttrOpt NDArrayHandle), '("bins", AttrOpt NDArrayHandle)]++_histogram ::+           forall args . Fullfilled "_histogram(ndarray)" args =>+             ArgsHMap "_histogram(ndarray)" args -> IO [NDArrayHandle]+_histogram args+  = let scalarArgs+          = catMaybes+              [("bin_cnt",) . showValue <$>+                 (args !? #bin_cnt :: Maybe (Maybe Int)),+               ("range",) . showValue <$> (args !? #range :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("bins",) <$> (args !? #bins :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_histogram"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_histogram_upd ::+               forall args . Fullfilled "_histogram(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "_histogram(ndarray)" args -> IO ()+_histogram_upd outputs args+  = let scalarArgs+          = catMaybes+              [("bin_cnt",) . showValue <$>+                 (args !? #bin_cnt :: Maybe (Maybe Int)),+               ("range",) . showValue <$> (args !? #range :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("bins",) <$> (args !? #bins :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_histogram"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "cast_storage(ndarray)" =+     '[ '("stype",+          AttrReq (EnumType '["csr", "default", "row_sparse"])),+        '("data", AttrOpt NDArrayHandle)]++cast_storage ::+             forall args . Fullfilled "cast_storage(ndarray)" args =>+               ArgsHMap "cast_storage(ndarray)" args -> IO [NDArrayHandle]+cast_storage args+  = let scalarArgs+          = catMaybes+              [("stype",) . showValue <$>+                 (args !? #stype ::+                    Maybe (EnumType '["csr", "default", "row_sparse"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cast_storage"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++cast_storage_upd ::+                 forall args . Fullfilled "cast_storage(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "cast_storage(ndarray)" args -> IO ()+cast_storage_upd outputs args+  = let scalarArgs+          = catMaybes+              [("stype",) . showValue <$>+                 (args !? #stype ::+                    Maybe (EnumType '["csr", "default", "row_sparse"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cast_storage"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_equal_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_equal_scalar ::+              forall args . Fullfilled "_equal_scalar(ndarray)" args =>+                ArgsHMap "_equal_scalar(ndarray)" args -> IO [NDArrayHandle]+_equal_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_equal_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_equal_scalar_upd ::+                  forall args . Fullfilled "_equal_scalar(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_equal_scalar(ndarray)" args -> IO ()+_equal_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_equal_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_not_equal_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_not_equal_scalar ::+                  forall args . Fullfilled "_not_equal_scalar(ndarray)" args =>+                    ArgsHMap "_not_equal_scalar(ndarray)" args -> IO [NDArrayHandle]+_not_equal_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_not_equal_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_not_equal_scalar_upd ::+                      forall args . Fullfilled "_not_equal_scalar(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_not_equal_scalar(ndarray)" args -> IO ()+_not_equal_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_not_equal_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_greater_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_greater_scalar ::+                forall args . Fullfilled "_greater_scalar(ndarray)" args =>+                  ArgsHMap "_greater_scalar(ndarray)" args -> IO [NDArrayHandle]+_greater_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_greater_scalar_upd ::+                    forall args . Fullfilled "_greater_scalar(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_greater_scalar(ndarray)" args -> IO ()+_greater_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_greater_equal_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_greater_equal_scalar ::+                      forall args . Fullfilled "_greater_equal_scalar(ndarray)" args =>+                        ArgsHMap "_greater_equal_scalar(ndarray)" args ->+                          IO [NDArrayHandle]+_greater_equal_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_equal_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_greater_equal_scalar_upd ::+                          forall args . Fullfilled "_greater_equal_scalar(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_greater_equal_scalar(ndarray)" args -> IO ()+_greater_equal_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_equal_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_lesser_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_lesser_scalar ::+               forall args . Fullfilled "_lesser_scalar(ndarray)" args =>+                 ArgsHMap "_lesser_scalar(ndarray)" args -> IO [NDArrayHandle]+_lesser_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_lesser_scalar_upd ::+                   forall args . Fullfilled "_lesser_scalar(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_lesser_scalar(ndarray)" args -> IO ()+_lesser_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_lesser_equal_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_lesser_equal_scalar ::+                     forall args . Fullfilled "_lesser_equal_scalar(ndarray)" args =>+                       ArgsHMap "_lesser_equal_scalar(ndarray)" args -> IO [NDArrayHandle]+_lesser_equal_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_equal_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_lesser_equal_scalar_upd ::+                         forall args . Fullfilled "_lesser_equal_scalar(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_lesser_equal_scalar(ndarray)" args -> IO ()+_lesser_equal_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_equal_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_logical_and_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_logical_and_scalar ::+                    forall args . Fullfilled "_logical_and_scalar(ndarray)" args =>+                      ArgsHMap "_logical_and_scalar(ndarray)" args -> IO [NDArrayHandle]+_logical_and_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_and_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_logical_and_scalar_upd ::+                        forall args . Fullfilled "_logical_and_scalar(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_logical_and_scalar(ndarray)" args -> IO ()+_logical_and_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_and_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_logical_or_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_logical_or_scalar ::+                   forall args . Fullfilled "_logical_or_scalar(ndarray)" args =>+                     ArgsHMap "_logical_or_scalar(ndarray)" args -> IO [NDArrayHandle]+_logical_or_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_or_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_logical_or_scalar_upd ::+                       forall args . Fullfilled "_logical_or_scalar(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_logical_or_scalar(ndarray)" args -> IO ()+_logical_or_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_or_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_logical_xor_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_logical_xor_scalar ::+                    forall args . Fullfilled "_logical_xor_scalar(ndarray)" args =>+                      ArgsHMap "_logical_xor_scalar(ndarray)" args -> IO [NDArrayHandle]+_logical_xor_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_xor_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_logical_xor_scalar_upd ::+                        forall args . Fullfilled "_logical_xor_scalar(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_logical_xor_scalar(ndarray)" args -> IO ()+_logical_xor_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_xor_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "relu(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++relu ::+     forall args . Fullfilled "relu(ndarray)" args =>+       ArgsHMap "relu(ndarray)" args -> IO [NDArrayHandle]+relu args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "relu"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++relu_upd ::+         forall args . Fullfilled "relu(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "relu(ndarray)" args -> IO ()+relu_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "relu"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_relu(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_relu ::+               forall args . Fullfilled "_backward_relu(ndarray)" args =>+                 ArgsHMap "_backward_relu(ndarray)" args -> IO [NDArrayHandle]+_backward_relu args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_relu"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_relu_upd ::+                   forall args . Fullfilled "_backward_relu(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_relu(ndarray)" args -> IO ()+_backward_relu_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_relu"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "sigmoid(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++sigmoid ::+        forall args . Fullfilled "sigmoid(ndarray)" args =>+          ArgsHMap "sigmoid(ndarray)" args -> IO [NDArrayHandle]+sigmoid args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sigmoid"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++sigmoid_upd ::+            forall args . Fullfilled "sigmoid(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "sigmoid(ndarray)" args -> IO ()+sigmoid_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sigmoid"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_sigmoid(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_sigmoid ::+                  forall args . Fullfilled "_backward_sigmoid(ndarray)" args =>+                    ArgsHMap "_backward_sigmoid(ndarray)" args -> IO [NDArrayHandle]+_backward_sigmoid args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sigmoid"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_sigmoid_upd ::+                      forall args . Fullfilled "_backward_sigmoid(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_sigmoid(ndarray)" args -> IO ()+_backward_sigmoid_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sigmoid"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "hard_sigmoid(ndarray)" =+     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle)]++hard_sigmoid ::+             forall args . Fullfilled "hard_sigmoid(ndarray)" args =>+               ArgsHMap "hard_sigmoid(ndarray)" args -> IO [NDArrayHandle]+hard_sigmoid args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "hard_sigmoid"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++hard_sigmoid_upd ::+                 forall args . Fullfilled "hard_sigmoid(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "hard_sigmoid(ndarray)" args -> IO ()+hard_sigmoid_upd outputs args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "hard_sigmoid"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_hard_sigmoid(ndarray)" = '[]++_backward_hard_sigmoid ::+                       forall args . Fullfilled "_backward_hard_sigmoid(ndarray)" args =>+                         ArgsHMap "_backward_hard_sigmoid(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_hard_sigmoid args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_hard_sigmoid"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_hard_sigmoid_upd ::+                           forall args . Fullfilled "_backward_hard_sigmoid(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_hard_sigmoid(ndarray)" args -> IO ()+_backward_hard_sigmoid_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_hard_sigmoid"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "softsign(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++softsign ::+         forall args . Fullfilled "softsign(ndarray)" args =>+           ArgsHMap "softsign(ndarray)" args -> IO [NDArrayHandle]+softsign args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softsign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++softsign_upd ::+             forall args . Fullfilled "softsign(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "softsign(ndarray)" args -> IO ()+softsign_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softsign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_softsign(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_softsign ::+                   forall args . Fullfilled "_backward_softsign(ndarray)" args =>+                     ArgsHMap "_backward_softsign(ndarray)" args -> IO [NDArrayHandle]+_backward_softsign args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_softsign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_softsign_upd ::+                       forall args . Fullfilled "_backward_softsign(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_backward_softsign(ndarray)" args -> IO ()+_backward_softsign_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_softsign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_copy(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_copy ::+      forall args . Fullfilled "_copy(ndarray)" args =>+        ArgsHMap "_copy(ndarray)" args -> IO [NDArrayHandle]+_copy args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_copy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_copy_upd ::+          forall args . Fullfilled "_copy(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "_copy(ndarray)" args -> IO ()+_copy_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_copy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_copy(ndarray)" = '[]++_backward_copy ::+               forall args . Fullfilled "_backward_copy(ndarray)" args =>+                 ArgsHMap "_backward_copy(ndarray)" args -> IO [NDArrayHandle]+_backward_copy args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_copy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_copy_upd ::+                   forall args . Fullfilled "_backward_copy(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_copy(ndarray)" args -> IO ()+_backward_copy_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_copy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_BlockGrad(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_BlockGrad ::+           forall args . Fullfilled "_BlockGrad(ndarray)" args =>+             ArgsHMap "_BlockGrad(ndarray)" args -> IO [NDArrayHandle]+_BlockGrad args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BlockGrad"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_BlockGrad_upd ::+               forall args . Fullfilled "_BlockGrad(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "_BlockGrad(ndarray)" args -> IO ()+_BlockGrad_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BlockGrad"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "make_loss(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++make_loss ::+          forall args . Fullfilled "make_loss(ndarray)" args =>+            ArgsHMap "make_loss(ndarray)" args -> IO [NDArrayHandle]+make_loss args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "make_loss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++make_loss_upd ::+              forall args . Fullfilled "make_loss(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "make_loss(ndarray)" args -> IO ()+make_loss_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "make_loss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_identity_with_attr_like_rhs(ndarray)"+     =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_identity_with_attr_like_rhs ::+                             forall args .+                               Fullfilled "_identity_with_attr_like_rhs(ndarray)" args =>+                               ArgsHMap "_identity_with_attr_like_rhs(ndarray)" args ->+                                 IO [NDArrayHandle]+_identity_with_attr_like_rhs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_identity_with_attr_like_rhs"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_identity_with_attr_like_rhs_upd ::+                                 forall args .+                                   Fullfilled "_identity_with_attr_like_rhs(ndarray)" args =>+                                   [NDArrayHandle] ->+                                     ArgsHMap "_identity_with_attr_like_rhs(ndarray)" args -> IO ()+_identity_with_attr_like_rhs_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_identity_with_attr_like_rhs"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "reshape_like(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++reshape_like ::+             forall args . Fullfilled "reshape_like(ndarray)" args =>+               ArgsHMap "reshape_like(ndarray)" args -> IO [NDArrayHandle]+reshape_like args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reshape_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++reshape_like_upd ::+                 forall args . Fullfilled "reshape_like(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "reshape_like(ndarray)" args -> IO ()+reshape_like_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reshape_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "shape_array(ndarray)" =+     '[ '("lhs_begin", AttrOpt (Maybe Int)),+        '("lhs_end", AttrOpt (Maybe Int)),+        '("rhs_begin", AttrOpt (Maybe Int)),+        '("rhs_end", AttrOpt (Maybe Int)),+        '("data", AttrOpt NDArrayHandle)]++shape_array ::+            forall args . Fullfilled "shape_array(ndarray)" args =>+              ArgsHMap "shape_array(ndarray)" args -> IO [NDArrayHandle]+shape_array args+  = let scalarArgs+          = catMaybes+              [("lhs_begin",) . showValue <$>+                 (args !? #lhs_begin :: Maybe (Maybe Int)),+               ("lhs_end",) . showValue <$>+                 (args !? #lhs_end :: Maybe (Maybe Int)),+               ("rhs_begin",) . showValue <$>+                 (args !? #rhs_begin :: Maybe (Maybe Int)),+               ("rhs_end",) . showValue <$>+                 (args !? #rhs_end :: Maybe (Maybe Int))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "shape_array"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++shape_array_upd ::+                forall args . Fullfilled "shape_array(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "shape_array(ndarray)" args -> IO ()+shape_array_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lhs_begin",) . showValue <$>+                 (args !? #lhs_begin :: Maybe (Maybe Int)),+               ("lhs_end",) . showValue <$>+                 (args !? #lhs_end :: Maybe (Maybe Int)),+               ("rhs_begin",) . showValue <$>+                 (args !? #rhs_begin :: Maybe (Maybe Int)),+               ("rhs_end",) . showValue <$>+                 (args !? #rhs_end :: Maybe (Maybe Int))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "shape_array"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "size_array(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++size_array ::+           forall args . Fullfilled "size_array(ndarray)" args =>+             ArgsHMap "size_array(ndarray)" args -> IO [NDArrayHandle]+size_array args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "size_array"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++size_array_upd ::+               forall args . Fullfilled "size_array(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "size_array(ndarray)" args -> IO ()+size_array_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "size_array"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Cast(ndarray)" =+     '[ '("dtype",+          AttrReq+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("data", AttrOpt NDArrayHandle)]++_Cast ::+      forall args . Fullfilled "_Cast(ndarray)" args =>+        ArgsHMap "_Cast(ndarray)" args -> IO [NDArrayHandle]+_Cast args+  = let scalarArgs+          = catMaybes+              [("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Cast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Cast_upd ::+          forall args . Fullfilled "_Cast(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "_Cast(ndarray)" args -> IO ()+_Cast_upd outputs args+  = let scalarArgs+          = catMaybes+              [("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Cast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_cast(ndarray)" = '[]++_backward_cast ::+               forall args . Fullfilled "_backward_cast(ndarray)" args =>+                 ArgsHMap "_backward_cast(ndarray)" args -> IO [NDArrayHandle]+_backward_cast args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_cast_upd ::+                   forall args . Fullfilled "_backward_cast(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_cast(ndarray)" args -> IO ()+_backward_cast_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "negative(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++negative ::+         forall args . Fullfilled "negative(ndarray)" args =>+           ArgsHMap "negative(ndarray)" args -> IO [NDArrayHandle]+negative args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "negative"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++negative_upd ::+             forall args . Fullfilled "negative(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "negative(ndarray)" args -> IO ()+negative_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "negative"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "reciprocal(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++reciprocal ::+           forall args . Fullfilled "reciprocal(ndarray)" args =>+             ArgsHMap "reciprocal(ndarray)" args -> IO [NDArrayHandle]+reciprocal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reciprocal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++reciprocal_upd ::+               forall args . Fullfilled "reciprocal(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "reciprocal(ndarray)" args -> IO ()+reciprocal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reciprocal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_reciprocal(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_reciprocal ::+                     forall args . Fullfilled "_backward_reciprocal(ndarray)" args =>+                       ArgsHMap "_backward_reciprocal(ndarray)" args -> IO [NDArrayHandle]+_backward_reciprocal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_reciprocal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_reciprocal_upd ::+                         forall args . Fullfilled "_backward_reciprocal(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_reciprocal(ndarray)" args -> IO ()+_backward_reciprocal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_reciprocal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "abs(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++abs ::+    forall args . Fullfilled "abs(ndarray)" args =>+      ArgsHMap "abs(ndarray)" args -> IO [NDArrayHandle]+abs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "abs"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++abs_upd ::+        forall args . Fullfilled "abs(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "abs(ndarray)" args -> IO ()+abs_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "abs"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_abs(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_abs ::+              forall args . Fullfilled "_backward_abs(ndarray)" args =>+                ArgsHMap "_backward_abs(ndarray)" args -> IO [NDArrayHandle]+_backward_abs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_abs"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_abs_upd ::+                  forall args . Fullfilled "_backward_abs(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_abs(ndarray)" args -> IO ()+_backward_abs_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_abs"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "sign(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++sign ::+     forall args . Fullfilled "sign(ndarray)" args =>+       ArgsHMap "sign(ndarray)" args -> IO [NDArrayHandle]+sign args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++sign_upd ::+         forall args . Fullfilled "sign(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "sign(ndarray)" args -> IO ()+sign_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_sign(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_sign ::+               forall args . Fullfilled "_backward_sign(ndarray)" args =>+                 ArgsHMap "_backward_sign(ndarray)" args -> IO [NDArrayHandle]+_backward_sign args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_sign_upd ::+                   forall args . Fullfilled "_backward_sign(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_sign(ndarray)" args -> IO ()+_backward_sign_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "round(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++round ::+      forall args . Fullfilled "round(ndarray)" args =>+        ArgsHMap "round(ndarray)" args -> IO [NDArrayHandle]+round args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "round"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++round_upd ::+          forall args . Fullfilled "round(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "round(ndarray)" args -> IO ()+round_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "round"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "rint(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++rint ::+     forall args . Fullfilled "rint(ndarray)" args =>+       ArgsHMap "rint(ndarray)" args -> IO [NDArrayHandle]+rint args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rint"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++rint_upd ::+         forall args . Fullfilled "rint(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "rint(ndarray)" args -> IO ()+rint_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rint"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "ceil(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++ceil ::+     forall args . Fullfilled "ceil(ndarray)" args =>+       ArgsHMap "ceil(ndarray)" args -> IO [NDArrayHandle]+ceil args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ceil"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++ceil_upd ::+         forall args . Fullfilled "ceil(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "ceil(ndarray)" args -> IO ()+ceil_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ceil"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "floor(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++floor ::+      forall args . Fullfilled "floor(ndarray)" args =>+        ArgsHMap "floor(ndarray)" args -> IO [NDArrayHandle]+floor args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "floor"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++floor_upd ::+          forall args . Fullfilled "floor(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "floor(ndarray)" args -> IO ()+floor_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "floor"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "trunc(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++trunc ::+      forall args . Fullfilled "trunc(ndarray)" args =>+        ArgsHMap "trunc(ndarray)" args -> IO [NDArrayHandle]+trunc args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "trunc"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++trunc_upd ::+          forall args . Fullfilled "trunc(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "trunc(ndarray)" args -> IO ()+trunc_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "trunc"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "fix(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++fix ::+    forall args . Fullfilled "fix(ndarray)" args =>+      ArgsHMap "fix(ndarray)" args -> IO [NDArrayHandle]+fix args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "fix"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++fix_upd ::+        forall args . Fullfilled "fix(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "fix(ndarray)" args -> IO ()+fix_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "fix"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "square(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++square ::+       forall args . Fullfilled "square(ndarray)" args =>+         ArgsHMap "square(ndarray)" args -> IO [NDArrayHandle]+square args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "square"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++square_upd ::+           forall args . Fullfilled "square(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "square(ndarray)" args -> IO ()+square_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "square"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_square(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_square ::+                 forall args . Fullfilled "_backward_square(ndarray)" args =>+                   ArgsHMap "_backward_square(ndarray)" args -> IO [NDArrayHandle]+_backward_square args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_square"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_square_upd ::+                     forall args . Fullfilled "_backward_square(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_backward_square(ndarray)" args -> IO ()+_backward_square_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_square"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "sqrt(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++sqrt ::+     forall args . Fullfilled "sqrt(ndarray)" args =>+       ArgsHMap "sqrt(ndarray)" args -> IO [NDArrayHandle]+sqrt args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sqrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++sqrt_upd ::+         forall args . Fullfilled "sqrt(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "sqrt(ndarray)" args -> IO ()+sqrt_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sqrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_sqrt(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_sqrt ::+               forall args . Fullfilled "_backward_sqrt(ndarray)" args =>+                 ArgsHMap "_backward_sqrt(ndarray)" args -> IO [NDArrayHandle]+_backward_sqrt args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sqrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_sqrt_upd ::+                   forall args . Fullfilled "_backward_sqrt(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_sqrt(ndarray)" args -> IO ()+_backward_sqrt_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sqrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "rsqrt(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++rsqrt ::+      forall args . Fullfilled "rsqrt(ndarray)" args =>+        ArgsHMap "rsqrt(ndarray)" args -> IO [NDArrayHandle]+rsqrt args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rsqrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++rsqrt_upd ::+          forall args . Fullfilled "rsqrt(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "rsqrt(ndarray)" args -> IO ()+rsqrt_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rsqrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_rsqrt(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_rsqrt ::+                forall args . Fullfilled "_backward_rsqrt(ndarray)" args =>+                  ArgsHMap "_backward_rsqrt(ndarray)" args -> IO [NDArrayHandle]+_backward_rsqrt args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rsqrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_rsqrt_upd ::+                    forall args . Fullfilled "_backward_rsqrt(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_rsqrt(ndarray)" args -> IO ()+_backward_rsqrt_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rsqrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "cbrt(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++cbrt ::+     forall args . Fullfilled "cbrt(ndarray)" args =>+       ArgsHMap "cbrt(ndarray)" args -> IO [NDArrayHandle]+cbrt args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cbrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++cbrt_upd ::+         forall args . Fullfilled "cbrt(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "cbrt(ndarray)" args -> IO ()+cbrt_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cbrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_cbrt(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_cbrt ::+               forall args . Fullfilled "_backward_cbrt(ndarray)" args =>+                 ArgsHMap "_backward_cbrt(ndarray)" args -> IO [NDArrayHandle]+_backward_cbrt args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cbrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_cbrt_upd ::+                   forall args . Fullfilled "_backward_cbrt(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_cbrt(ndarray)" args -> IO ()+_backward_cbrt_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cbrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "rcbrt(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++rcbrt ::+      forall args . Fullfilled "rcbrt(ndarray)" args =>+        ArgsHMap "rcbrt(ndarray)" args -> IO [NDArrayHandle]+rcbrt args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rcbrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++rcbrt_upd ::+          forall args . Fullfilled "rcbrt(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "rcbrt(ndarray)" args -> IO ()+rcbrt_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rcbrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_rcbrt(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_rcbrt ::+                forall args . Fullfilled "_backward_rcbrt(ndarray)" args =>+                  ArgsHMap "_backward_rcbrt(ndarray)" args -> IO [NDArrayHandle]+_backward_rcbrt args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rcbrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_rcbrt_upd ::+                    forall args . Fullfilled "_backward_rcbrt(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_rcbrt(ndarray)" args -> IO ()+_backward_rcbrt_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rcbrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "exp(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++exp ::+    forall args . Fullfilled "exp(ndarray)" args =>+      ArgsHMap "exp(ndarray)" args -> IO [NDArrayHandle]+exp args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "exp"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++exp_upd ::+        forall args . Fullfilled "exp(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "exp(ndarray)" args -> IO ()+exp_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "exp"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "log(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++log ::+    forall args . Fullfilled "log(ndarray)" args =>+      ArgsHMap "log(ndarray)" args -> IO [NDArrayHandle]+log args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++log_upd ::+        forall args . Fullfilled "log(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "log(ndarray)" args -> IO ()+log_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "log10(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++log10 ::+      forall args . Fullfilled "log10(ndarray)" args =>+        ArgsHMap "log10(ndarray)" args -> IO [NDArrayHandle]+log10 args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log10"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++log10_upd ::+          forall args . Fullfilled "log10(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "log10(ndarray)" args -> IO ()+log10_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log10"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "log2(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++log2 ::+     forall args . Fullfilled "log2(ndarray)" args =>+       ArgsHMap "log2(ndarray)" args -> IO [NDArrayHandle]+log2 args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log2"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++log2_upd ::+         forall args . Fullfilled "log2(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "log2(ndarray)" args -> IO ()+log2_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log2"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_log(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_log ::+              forall args . Fullfilled "_backward_log(ndarray)" args =>+                ArgsHMap "_backward_log(ndarray)" args -> IO [NDArrayHandle]+_backward_log args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_log_upd ::+                  forall args . Fullfilled "_backward_log(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_log(ndarray)" args -> IO ()+_backward_log_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_log10(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_log10 ::+                forall args . Fullfilled "_backward_log10(ndarray)" args =>+                  ArgsHMap "_backward_log10(ndarray)" args -> IO [NDArrayHandle]+_backward_log10 args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log10"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_log10_upd ::+                    forall args . Fullfilled "_backward_log10(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_log10(ndarray)" args -> IO ()+_backward_log10_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log10"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_log2(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_log2 ::+               forall args . Fullfilled "_backward_log2(ndarray)" args =>+                 ArgsHMap "_backward_log2(ndarray)" args -> IO [NDArrayHandle]+_backward_log2 args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log2"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_log2_upd ::+                   forall args . Fullfilled "_backward_log2(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_log2(ndarray)" args -> IO ()+_backward_log2_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log2"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "log1p(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++log1p ::+      forall args . Fullfilled "log1p(ndarray)" args =>+        ArgsHMap "log1p(ndarray)" args -> IO [NDArrayHandle]+log1p args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log1p"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++log1p_upd ::+          forall args . Fullfilled "log1p(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "log1p(ndarray)" args -> IO ()+log1p_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log1p"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_log1p(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_log1p ::+                forall args . Fullfilled "_backward_log1p(ndarray)" args =>+                  ArgsHMap "_backward_log1p(ndarray)" args -> IO [NDArrayHandle]+_backward_log1p args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log1p"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_log1p_upd ::+                    forall args . Fullfilled "_backward_log1p(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_log1p(ndarray)" args -> IO ()+_backward_log1p_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log1p"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "expm1(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++expm1 ::+      forall args . Fullfilled "expm1(ndarray)" args =>+        ArgsHMap "expm1(ndarray)" args -> IO [NDArrayHandle]+expm1 args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "expm1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++expm1_upd ::+          forall args . Fullfilled "expm1(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "expm1(ndarray)" args -> IO ()+expm1_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "expm1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_expm1(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_expm1 ::+                forall args . Fullfilled "_backward_expm1(ndarray)" args =>+                  ArgsHMap "_backward_expm1(ndarray)" args -> IO [NDArrayHandle]+_backward_expm1 args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_expm1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_expm1_upd ::+                    forall args . Fullfilled "_backward_expm1(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_expm1(ndarray)" args -> IO ()+_backward_expm1_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_expm1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "gamma(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++gamma ::+      forall args . Fullfilled "gamma(ndarray)" args =>+        ArgsHMap "gamma(ndarray)" args -> IO [NDArrayHandle]+gamma args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gamma"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++gamma_upd ::+          forall args . Fullfilled "gamma(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "gamma(ndarray)" args -> IO ()+gamma_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gamma"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_gamma(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_gamma ::+                forall args . Fullfilled "_backward_gamma(ndarray)" args =>+                  ArgsHMap "_backward_gamma(ndarray)" args -> IO [NDArrayHandle]+_backward_gamma args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_gamma"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_gamma_upd ::+                    forall args . Fullfilled "_backward_gamma(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_gamma(ndarray)" args -> IO ()+_backward_gamma_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_gamma"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "gammaln(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++gammaln ::+        forall args . Fullfilled "gammaln(ndarray)" args =>+          ArgsHMap "gammaln(ndarray)" args -> IO [NDArrayHandle]+gammaln args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gammaln"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++gammaln_upd ::+            forall args . Fullfilled "gammaln(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "gammaln(ndarray)" args -> IO ()+gammaln_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gammaln"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_gammaln(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_gammaln ::+                  forall args . Fullfilled "_backward_gammaln(ndarray)" args =>+                    ArgsHMap "_backward_gammaln(ndarray)" args -> IO [NDArrayHandle]+_backward_gammaln args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_gammaln"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_gammaln_upd ::+                      forall args . Fullfilled "_backward_gammaln(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_gammaln(ndarray)" args -> IO ()+_backward_gammaln_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_gammaln"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "logical_not(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++logical_not ::+            forall args . Fullfilled "logical_not(ndarray)" args =>+              ArgsHMap "logical_not(ndarray)" args -> IO [NDArrayHandle]+logical_not args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "logical_not"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++logical_not_upd ::+                forall args . Fullfilled "logical_not(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "logical_not(ndarray)" args -> IO ()+logical_not_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "logical_not"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "sum(ndarray)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++sum ::+    forall args . Fullfilled "sum(ndarray)" args =>+      ArgsHMap "sum(ndarray)" args -> IO [NDArrayHandle]+sum args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++sum_upd ::+        forall args . Fullfilled "sum(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "sum(ndarray)" args -> IO ()+sum_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_sum(ndarray)" = '[]++_backward_sum ::+              forall args . Fullfilled "_backward_sum(ndarray)" args =>+                ArgsHMap "_backward_sum(ndarray)" args -> IO [NDArrayHandle]+_backward_sum args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_sum_upd ::+                  forall args . Fullfilled "_backward_sum(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_sum(ndarray)" args -> IO ()+_backward_sum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "mean(ndarray)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++mean ::+     forall args . Fullfilled "mean(ndarray)" args =>+       ArgsHMap "mean(ndarray)" args -> IO [NDArrayHandle]+mean args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mean"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++mean_upd ::+         forall args . Fullfilled "mean(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "mean(ndarray)" args -> IO ()+mean_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mean"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_mean(ndarray)" = '[]++_backward_mean ::+               forall args . Fullfilled "_backward_mean(ndarray)" args =>+                 ArgsHMap "_backward_mean(ndarray)" args -> IO [NDArrayHandle]+_backward_mean args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mean"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_mean_upd ::+                   forall args . Fullfilled "_backward_mean(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_mean(ndarray)" args -> IO ()+_backward_mean_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mean"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "prod(ndarray)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++prod ::+     forall args . Fullfilled "prod(ndarray)" args =>+       ArgsHMap "prod(ndarray)" args -> IO [NDArrayHandle]+prod args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "prod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++prod_upd ::+         forall args . Fullfilled "prod(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "prod(ndarray)" args -> IO ()+prod_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "prod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_prod(ndarray)" = '[]++_backward_prod ::+               forall args . Fullfilled "_backward_prod(ndarray)" args =>+                 ArgsHMap "_backward_prod(ndarray)" args -> IO [NDArrayHandle]+_backward_prod args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_prod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_prod_upd ::+                   forall args . Fullfilled "_backward_prod(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_prod(ndarray)" args -> IO ()+_backward_prod_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_prod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "nansum(ndarray)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++nansum ::+       forall args . Fullfilled "nansum(ndarray)" args =>+         ArgsHMap "nansum(ndarray)" args -> IO [NDArrayHandle]+nansum args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "nansum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++nansum_upd ::+           forall args . Fullfilled "nansum(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "nansum(ndarray)" args -> IO ()+nansum_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "nansum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_nansum(ndarray)" = '[]++_backward_nansum ::+                 forall args . Fullfilled "_backward_nansum(ndarray)" args =>+                   ArgsHMap "_backward_nansum(ndarray)" args -> IO [NDArrayHandle]+_backward_nansum args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_nansum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_nansum_upd ::+                     forall args . Fullfilled "_backward_nansum(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_backward_nansum(ndarray)" args -> IO ()+_backward_nansum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_nansum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "nanprod(ndarray)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++nanprod ::+        forall args . Fullfilled "nanprod(ndarray)" args =>+          ArgsHMap "nanprod(ndarray)" args -> IO [NDArrayHandle]+nanprod args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "nanprod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++nanprod_upd ::+            forall args . Fullfilled "nanprod(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "nanprod(ndarray)" args -> IO ()+nanprod_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "nanprod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_nanprod(ndarray)" = '[]++_backward_nanprod ::+                  forall args . Fullfilled "_backward_nanprod(ndarray)" args =>+                    ArgsHMap "_backward_nanprod(ndarray)" args -> IO [NDArrayHandle]+_backward_nanprod args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_nanprod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_nanprod_upd ::+                      forall args . Fullfilled "_backward_nanprod(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_nanprod(ndarray)" args -> IO ()+_backward_nanprod_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_nanprod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "max(ndarray)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++max ::+    forall args . Fullfilled "max(ndarray)" args =>+      ArgsHMap "max(ndarray)" args -> IO [NDArrayHandle]+max args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "max"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++max_upd ::+        forall args . Fullfilled "max(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "max(ndarray)" args -> IO ()+max_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "max"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_max(ndarray)" = '[]++_backward_max ::+              forall args . Fullfilled "_backward_max(ndarray)" args =>+                ArgsHMap "_backward_max(ndarray)" args -> IO [NDArrayHandle]+_backward_max args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_max"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_max_upd ::+                  forall args . Fullfilled "_backward_max(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_max(ndarray)" args -> IO ()+_backward_max_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_max"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "min(ndarray)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++min ::+    forall args . Fullfilled "min(ndarray)" args =>+      ArgsHMap "min(ndarray)" args -> IO [NDArrayHandle]+min args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "min"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++min_upd ::+        forall args . Fullfilled "min(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "min(ndarray)" args -> IO ()+min_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "min"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_min(ndarray)" = '[]++_backward_min ::+              forall args . Fullfilled "_backward_min(ndarray)" args =>+                ArgsHMap "_backward_min(ndarray)" args -> IO [NDArrayHandle]+_backward_min args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_min"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_min_upd ::+                  forall args . Fullfilled "_backward_min(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_min(ndarray)" args -> IO ()+_backward_min_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_min"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_axis(ndarray)" =+     '[ '("axis", AttrOpt [Int]), '("size", AttrOpt [Int]),+        '("data", AttrOpt NDArrayHandle)]++broadcast_axis ::+               forall args . Fullfilled "broadcast_axis(ndarray)" args =>+                 ArgsHMap "broadcast_axis(ndarray)" args -> IO [NDArrayHandle]+broadcast_axis args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),+               ("size",) . showValue <$> (args !? #size :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_axis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_axis_upd ::+                   forall args . Fullfilled "broadcast_axis(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "broadcast_axis(ndarray)" args -> IO ()+broadcast_axis_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),+               ("size",) . showValue <$> (args !? #size :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_axis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_to(ndarray)" =+     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]++broadcast_to ::+             forall args . Fullfilled "broadcast_to(ndarray)" args =>+               ArgsHMap "broadcast_to(ndarray)" args -> IO [NDArrayHandle]+broadcast_to args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_to"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_to_upd ::+                 forall args . Fullfilled "broadcast_to(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "broadcast_to(ndarray)" args -> IO ()+broadcast_to_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_to"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_broadcast_backward(ndarray)" = '[]++_broadcast_backward ::+                    forall args . Fullfilled "_broadcast_backward(ndarray)" args =>+                      ArgsHMap "_broadcast_backward(ndarray)" args -> IO [NDArrayHandle]+_broadcast_backward args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_broadcast_backward"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_broadcast_backward_upd ::+                        forall args . Fullfilled "_broadcast_backward(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_broadcast_backward(ndarray)" args -> IO ()+_broadcast_backward_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_broadcast_backward"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_like(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_like ::+               forall args . Fullfilled "broadcast_like(ndarray)" args =>+                 ArgsHMap "broadcast_like(ndarray)" args -> IO [NDArrayHandle]+broadcast_like args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_like_upd ::+                   forall args . Fullfilled "broadcast_like(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "broadcast_like(ndarray)" args -> IO ()+broadcast_like_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "norm(ndarray)" =+     '[ '("ord", AttrOpt Int), '("axis", AttrOpt (Maybe [Int])),+        '("keepdims", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++norm ::+     forall args . Fullfilled "norm(ndarray)" args =>+       ArgsHMap "norm(ndarray)" args -> IO [NDArrayHandle]+norm args+  = let scalarArgs+          = catMaybes+              [("ord",) . showValue <$> (args !? #ord :: Maybe Int),+               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "norm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++norm_upd ::+         forall args . Fullfilled "norm(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "norm(ndarray)" args -> IO ()+norm_upd outputs args+  = let scalarArgs+          = catMaybes+              [("ord",) . showValue <$> (args !? #ord :: Maybe Int),+               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "norm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_norm(ndarray)" = '[]++_backward_norm ::+               forall args . Fullfilled "_backward_norm(ndarray)" args =>+                 ArgsHMap "_backward_norm(ndarray)" args -> IO [NDArrayHandle]+_backward_norm args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_norm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_norm_upd ::+                   forall args . Fullfilled "_backward_norm(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_norm(ndarray)" args -> IO ()+_backward_norm_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_norm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "elemwise_add(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++elemwise_add ::+             forall args . Fullfilled "elemwise_add(ndarray)" args =>+               ArgsHMap "elemwise_add(ndarray)" args -> IO [NDArrayHandle]+elemwise_add args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++elemwise_add_upd ::+                 forall args . Fullfilled "elemwise_add(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "elemwise_add(ndarray)" args -> IO ()+elemwise_add_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_grad_add(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_grad_add ::+          forall args . Fullfilled "_grad_add(ndarray)" args =>+            ArgsHMap "_grad_add(ndarray)" args -> IO [NDArrayHandle]+_grad_add args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_grad_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_grad_add_upd ::+              forall args . Fullfilled "_grad_add(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "_grad_add(ndarray)" args -> IO ()+_grad_add_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_grad_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_add(ndarray)" = '[]++_backward_add ::+              forall args . Fullfilled "_backward_add(ndarray)" args =>+                ArgsHMap "_backward_add(ndarray)" args -> IO [NDArrayHandle]+_backward_add args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_add_upd ::+                  forall args . Fullfilled "_backward_add(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_add(ndarray)" args -> IO ()+_backward_add_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "elemwise_sub(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++elemwise_sub ::+             forall args . Fullfilled "elemwise_sub(ndarray)" args =>+               ArgsHMap "elemwise_sub(ndarray)" args -> IO [NDArrayHandle]+elemwise_sub args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_sub"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++elemwise_sub_upd ::+                 forall args . Fullfilled "elemwise_sub(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "elemwise_sub(ndarray)" args -> IO ()+elemwise_sub_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_sub"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_sub(ndarray)" = '[]++_backward_sub ::+              forall args . Fullfilled "_backward_sub(ndarray)" args =>+                ArgsHMap "_backward_sub(ndarray)" args -> IO [NDArrayHandle]+_backward_sub args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sub"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_sub_upd ::+                  forall args . Fullfilled "_backward_sub(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_sub(ndarray)" args -> IO ()+_backward_sub_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sub"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "elemwise_mul(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++elemwise_mul ::+             forall args . Fullfilled "elemwise_mul(ndarray)" args =>+               ArgsHMap "elemwise_mul(ndarray)" args -> IO [NDArrayHandle]+elemwise_mul args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_mul"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++elemwise_mul_upd ::+                 forall args . Fullfilled "elemwise_mul(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "elemwise_mul(ndarray)" args -> IO ()+elemwise_mul_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_mul"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_mul(ndarray)" = '[]++_backward_mul ::+              forall args . Fullfilled "_backward_mul(ndarray)" args =>+                ArgsHMap "_backward_mul(ndarray)" args -> IO [NDArrayHandle]+_backward_mul args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mul"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_mul_upd ::+                  forall args . Fullfilled "_backward_mul(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_mul(ndarray)" args -> IO ()+_backward_mul_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mul"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "elemwise_div(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++elemwise_div ::+             forall args . Fullfilled "elemwise_div(ndarray)" args =>+               ArgsHMap "elemwise_div(ndarray)" args -> IO [NDArrayHandle]+elemwise_div args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++elemwise_div_upd ::+                 forall args . Fullfilled "elemwise_div(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "elemwise_div(ndarray)" args -> IO ()+elemwise_div_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_div(ndarray)" = '[]++_backward_div ::+              forall args . Fullfilled "_backward_div(ndarray)" args =>+                ArgsHMap "_backward_div(ndarray)" args -> IO [NDArrayHandle]+_backward_div args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_div_upd ::+                  forall args . Fullfilled "_backward_div(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_div(ndarray)" args -> IO ()+_backward_div_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_mod(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_mod ::+     forall args . Fullfilled "_mod(ndarray)" args =>+       ArgsHMap "_mod(ndarray)" args -> IO [NDArrayHandle]+_mod args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_mod_upd ::+         forall args . Fullfilled "_mod(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "_mod(ndarray)" args -> IO ()+_mod_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_mod(ndarray)" = '[]++_backward_mod ::+              forall args . Fullfilled "_backward_mod(ndarray)" args =>+                ArgsHMap "_backward_mod(ndarray)" args -> IO [NDArrayHandle]+_backward_mod args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_mod_upd ::+                  forall args . Fullfilled "_backward_mod(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_mod(ndarray)" args -> IO ()+_backward_mod_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_scatter_elemwise_div(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_scatter_elemwise_div ::+                      forall args . Fullfilled "_scatter_elemwise_div(ndarray)" args =>+                        ArgsHMap "_scatter_elemwise_div(ndarray)" args ->+                          IO [NDArrayHandle]+_scatter_elemwise_div args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_elemwise_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_scatter_elemwise_div_upd ::+                          forall args . Fullfilled "_scatter_elemwise_div(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_scatter_elemwise_div(ndarray)" args -> IO ()+_scatter_elemwise_div_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_elemwise_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_scatter_plus_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_scatter_plus_scalar ::+                     forall args . Fullfilled "_scatter_plus_scalar(ndarray)" args =>+                       ArgsHMap "_scatter_plus_scalar(ndarray)" args -> IO [NDArrayHandle]+_scatter_plus_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_plus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_scatter_plus_scalar_upd ::+                         forall args . Fullfilled "_scatter_plus_scalar(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_scatter_plus_scalar(ndarray)" args -> IO ()+_scatter_plus_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_plus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_scatter_minus_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_scatter_minus_scalar ::+                      forall args . Fullfilled "_scatter_minus_scalar(ndarray)" args =>+                        ArgsHMap "_scatter_minus_scalar(ndarray)" args ->+                          IO [NDArrayHandle]+_scatter_minus_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_minus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_scatter_minus_scalar_upd ::+                          forall args . Fullfilled "_scatter_minus_scalar(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_scatter_minus_scalar(ndarray)" args -> IO ()+_scatter_minus_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_minus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Embedding(ndarray)" =+     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("sparse_grad", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),+        '("weight", AttrOpt NDArrayHandle)]++_Embedding ::+           forall args . Fullfilled "_Embedding(ndarray)" args =>+             ArgsHMap "_Embedding(ndarray)" args -> IO [NDArrayHandle]+_Embedding args+  = let scalarArgs+          = catMaybes+              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"])),+               ("sparse_grad",) . showValue <$>+                 (args !? #sparse_grad :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Embedding"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Embedding_upd ::+               forall args . Fullfilled "_Embedding(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "_Embedding(ndarray)" args -> IO ()+_Embedding_upd outputs args+  = let scalarArgs+          = catMaybes+              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"])),+               ("sparse_grad",) . showValue <$>+                 (args !? #sparse_grad :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Embedding"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_SparseEmbedding(ndarray)" =+     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("sparse_grad", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),+        '("weight", AttrOpt NDArrayHandle)]++_contrib_SparseEmbedding ::+                         forall args .+                           Fullfilled "_contrib_SparseEmbedding(ndarray)" args =>+                           ArgsHMap "_contrib_SparseEmbedding(ndarray)" args ->+                             IO [NDArrayHandle]+_contrib_SparseEmbedding args+  = let scalarArgs+          = catMaybes+              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"])),+               ("sparse_grad",) . showValue <$>+                 (args !? #sparse_grad :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_SparseEmbedding"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_SparseEmbedding_upd ::+                             forall args .+                               Fullfilled "_contrib_SparseEmbedding(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_contrib_SparseEmbedding(ndarray)" args -> IO ()+_contrib_SparseEmbedding_upd outputs args+  = let scalarArgs+          = catMaybes+              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"])),+               ("sparse_grad",) . showValue <$>+                 (args !? #sparse_grad :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_SparseEmbedding"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Embedding(ndarray)" = '[]++_backward_Embedding ::+                    forall args . Fullfilled "_backward_Embedding(ndarray)" args =>+                      ArgsHMap "_backward_Embedding(ndarray)" args -> IO [NDArrayHandle]+_backward_Embedding args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Embedding"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Embedding_upd ::+                        forall args . Fullfilled "_backward_Embedding(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_backward_Embedding(ndarray)" args -> IO ()+_backward_Embedding_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Embedding"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SparseEmbedding(ndarray)" =+     '[]++_backward_SparseEmbedding ::+                          forall args .+                            Fullfilled "_backward_SparseEmbedding(ndarray)" args =>+                            ArgsHMap "_backward_SparseEmbedding(ndarray)" args ->+                              IO [NDArrayHandle]+_backward_SparseEmbedding args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SparseEmbedding"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SparseEmbedding_upd ::+                              forall args .+                                Fullfilled "_backward_SparseEmbedding(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_backward_SparseEmbedding(ndarray)" args -> IO ()+_backward_SparseEmbedding_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SparseEmbedding"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "take(ndarray)" =+     '[ '("axis", AttrOpt Int),+        '("mode", AttrOpt (EnumType '["clip", "raise", "wrap"])),+        '("a", AttrOpt NDArrayHandle), '("indices", AttrOpt NDArrayHandle)]++take ::+     forall args . Fullfilled "take(ndarray)" args =>+       ArgsHMap "take(ndarray)" args -> IO [NDArrayHandle]+take args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))]+        tensorArgs+          = catMaybes+              [("a",) <$> (args !? #a :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "take"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++take_upd ::+         forall args . Fullfilled "take(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "take(ndarray)" args -> IO ()+take_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))]+        tensorArgs+          = catMaybes+              [("a",) <$> (args !? #a :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "take"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_take(ndarray)" = '[]++_backward_take ::+               forall args . Fullfilled "_backward_take(ndarray)" args =>+                 ArgsHMap "_backward_take(ndarray)" args -> IO [NDArrayHandle]+_backward_take args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_take"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_take_upd ::+                   forall args . Fullfilled "_backward_take(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_take(ndarray)" args -> IO ()+_backward_take_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_take"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "batch_take(ndarray)" =+     '[ '("a", AttrOpt NDArrayHandle),+        '("indices", AttrOpt NDArrayHandle)]++batch_take ::+           forall args . Fullfilled "batch_take(ndarray)" args =>+             ArgsHMap "batch_take(ndarray)" args -> IO [NDArrayHandle]+batch_take args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("a",) <$> (args !? #a :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "batch_take"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++batch_take_upd ::+               forall args . Fullfilled "batch_take(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "batch_take(ndarray)" args -> IO ()+batch_take_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("a",) <$> (args !? #a :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "batch_take"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "one_hot(ndarray)" =+     '[ '("depth", AttrReq Int), '("on_value", AttrOpt Double),+        '("off_value", AttrOpt Double),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("indices", AttrOpt NDArrayHandle)]++one_hot ::+        forall args . Fullfilled "one_hot(ndarray)" args =>+          ArgsHMap "one_hot(ndarray)" args -> IO [NDArrayHandle]+one_hot args+  = let scalarArgs+          = catMaybes+              [("depth",) . showValue <$> (args !? #depth :: Maybe Int),+               ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double),+               ("off_value",) . showValue <$>+                 (args !? #off_value :: Maybe Double),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs+          = catMaybes+              [("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "one_hot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++one_hot_upd ::+            forall args . Fullfilled "one_hot(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "one_hot(ndarray)" args -> IO ()+one_hot_upd outputs args+  = let scalarArgs+          = catMaybes+              [("depth",) . showValue <$> (args !? #depth :: Maybe Int),+               ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double),+               ("off_value",) . showValue <$>+                 (args !? #off_value :: Maybe Double),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs+          = catMaybes+              [("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "one_hot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "gather_nd(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle),+        '("indices", AttrOpt NDArrayHandle)]++gather_nd ::+          forall args . Fullfilled "gather_nd(ndarray)" args =>+            ArgsHMap "gather_nd(ndarray)" args -> IO [NDArrayHandle]+gather_nd args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gather_nd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++gather_nd_upd ::+              forall args . Fullfilled "gather_nd(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "gather_nd(ndarray)" args -> IO ()+gather_nd_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gather_nd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "scatter_nd(ndarray)" =+     '[ '("shape", AttrReq [Int]), '("data", AttrOpt NDArrayHandle),+        '("indices", AttrOpt NDArrayHandle)]++scatter_nd ::+           forall args . Fullfilled "scatter_nd(ndarray)" args =>+             ArgsHMap "scatter_nd(ndarray)" args -> IO [NDArrayHandle]+scatter_nd args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "scatter_nd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++scatter_nd_upd ::+               forall args . Fullfilled "scatter_nd(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "scatter_nd(ndarray)" args -> IO ()+scatter_nd_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "scatter_nd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_gather_nd(ndarray)" =+     '[ '("shape", AttrReq [Int]), '("data", AttrOpt NDArrayHandle),+        '("indices", AttrOpt NDArrayHandle)]++_backward_gather_nd ::+                    forall args . Fullfilled "_backward_gather_nd(ndarray)" args =>+                      ArgsHMap "_backward_gather_nd(ndarray)" args -> IO [NDArrayHandle]+_backward_gather_nd args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_gather_nd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_gather_nd_upd ::+                        forall args . Fullfilled "_backward_gather_nd(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_backward_gather_nd(ndarray)" args -> IO ()+_backward_gather_nd_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_gather_nd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_scatter_set_nd(ndarray)" =+     '[ '("shape", AttrReq [Int]), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle),+        '("indices", AttrOpt NDArrayHandle)]++_scatter_set_nd ::+                forall args . Fullfilled "_scatter_set_nd(ndarray)" args =>+                  ArgsHMap "_scatter_set_nd(ndarray)" args -> IO [NDArrayHandle]+_scatter_set_nd args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_set_nd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_scatter_set_nd_upd ::+                    forall args . Fullfilled "_scatter_set_nd(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_scatter_set_nd(ndarray)" args -> IO ()+_scatter_set_nd_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_set_nd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_equal(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_equal ::+                forall args . Fullfilled "broadcast_equal(ndarray)" args =>+                  ArgsHMap "broadcast_equal(ndarray)" args -> IO [NDArrayHandle]+broadcast_equal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_equal_upd ::+                    forall args . Fullfilled "broadcast_equal(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "broadcast_equal(ndarray)" args -> IO ()+broadcast_equal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_not_equal(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_not_equal ::+                    forall args . Fullfilled "broadcast_not_equal(ndarray)" args =>+                      ArgsHMap "broadcast_not_equal(ndarray)" args -> IO [NDArrayHandle]+broadcast_not_equal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_not_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_not_equal_upd ::+                        forall args . Fullfilled "broadcast_not_equal(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "broadcast_not_equal(ndarray)" args -> IO ()+broadcast_not_equal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_not_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_greater(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_greater ::+                  forall args . Fullfilled "broadcast_greater(ndarray)" args =>+                    ArgsHMap "broadcast_greater(ndarray)" args -> IO [NDArrayHandle]+broadcast_greater args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_greater"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_greater_upd ::+                      forall args . Fullfilled "broadcast_greater(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "broadcast_greater(ndarray)" args -> IO ()+broadcast_greater_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_greater"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_greater_equal(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_greater_equal ::+                        forall args . Fullfilled "broadcast_greater_equal(ndarray)" args =>+                          ArgsHMap "broadcast_greater_equal(ndarray)" args ->+                            IO [NDArrayHandle]+broadcast_greater_equal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_greater_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_greater_equal_upd ::+                            forall args . Fullfilled "broadcast_greater_equal(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "broadcast_greater_equal(ndarray)" args -> IO ()+broadcast_greater_equal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_greater_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_lesser(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_lesser ::+                 forall args . Fullfilled "broadcast_lesser(ndarray)" args =>+                   ArgsHMap "broadcast_lesser(ndarray)" args -> IO [NDArrayHandle]+broadcast_lesser args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_lesser"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_lesser_upd ::+                     forall args . Fullfilled "broadcast_lesser(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "broadcast_lesser(ndarray)" args -> IO ()+broadcast_lesser_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_lesser"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_lesser_equal(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_lesser_equal ::+                       forall args . Fullfilled "broadcast_lesser_equal(ndarray)" args =>+                         ArgsHMap "broadcast_lesser_equal(ndarray)" args ->+                           IO [NDArrayHandle]+broadcast_lesser_equal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_lesser_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_lesser_equal_upd ::+                           forall args . Fullfilled "broadcast_lesser_equal(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "broadcast_lesser_equal(ndarray)" args -> IO ()+broadcast_lesser_equal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_lesser_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_logical_and(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_logical_and ::+                      forall args . Fullfilled "broadcast_logical_and(ndarray)" args =>+                        ArgsHMap "broadcast_logical_and(ndarray)" args ->+                          IO [NDArrayHandle]+broadcast_logical_and args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_logical_and"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_logical_and_upd ::+                          forall args . Fullfilled "broadcast_logical_and(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "broadcast_logical_and(ndarray)" args -> IO ()+broadcast_logical_and_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_logical_and"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_logical_or(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_logical_or ::+                     forall args . Fullfilled "broadcast_logical_or(ndarray)" args =>+                       ArgsHMap "broadcast_logical_or(ndarray)" args -> IO [NDArrayHandle]+broadcast_logical_or args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_logical_or"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_logical_or_upd ::+                         forall args . Fullfilled "broadcast_logical_or(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "broadcast_logical_or(ndarray)" args -> IO ()+broadcast_logical_or_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_logical_or"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_logical_xor(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_logical_xor ::+                      forall args . Fullfilled "broadcast_logical_xor(ndarray)" args =>+                        ArgsHMap "broadcast_logical_xor(ndarray)" args ->+                          IO [NDArrayHandle]+broadcast_logical_xor args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_logical_xor"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_logical_xor_upd ::+                          forall args . Fullfilled "broadcast_logical_xor(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "broadcast_logical_xor(ndarray)" args -> IO ()+broadcast_logical_xor_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_logical_xor"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_plus_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_plus_scalar ::+             forall args . Fullfilled "_plus_scalar(ndarray)" args =>+               ArgsHMap "_plus_scalar(ndarray)" args -> IO [NDArrayHandle]+_plus_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_plus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_plus_scalar_upd ::+                 forall args . Fullfilled "_plus_scalar(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_plus_scalar(ndarray)" args -> IO ()+_plus_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_plus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_minus_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_minus_scalar ::+              forall args . Fullfilled "_minus_scalar(ndarray)" args =>+                ArgsHMap "_minus_scalar(ndarray)" args -> IO [NDArrayHandle]+_minus_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_minus_scalar_upd ::+                  forall args . Fullfilled "_minus_scalar(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_minus_scalar(ndarray)" args -> IO ()+_minus_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_rminus_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_rminus_scalar ::+               forall args . Fullfilled "_rminus_scalar(ndarray)" args =>+                 ArgsHMap "_rminus_scalar(ndarray)" args -> IO [NDArrayHandle]+_rminus_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rminus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_rminus_scalar_upd ::+                   forall args . Fullfilled "_rminus_scalar(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_rminus_scalar(ndarray)" args -> IO ()+_rminus_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rminus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_mul_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_mul_scalar ::+            forall args . Fullfilled "_mul_scalar(ndarray)" args =>+              ArgsHMap "_mul_scalar(ndarray)" args -> IO [NDArrayHandle]+_mul_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mul_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_mul_scalar_upd ::+                forall args . Fullfilled "_mul_scalar(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_mul_scalar(ndarray)" args -> IO ()+_mul_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mul_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_mul_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_backward_mul_scalar ::+                     forall args . Fullfilled "_backward_mul_scalar(ndarray)" args =>+                       ArgsHMap "_backward_mul_scalar(ndarray)" args -> IO [NDArrayHandle]+_backward_mul_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mul_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_mul_scalar_upd ::+                         forall args . Fullfilled "_backward_mul_scalar(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_mul_scalar(ndarray)" args -> IO ()+_backward_mul_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mul_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_div_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_div_scalar ::+            forall args . Fullfilled "_div_scalar(ndarray)" args =>+              ArgsHMap "_div_scalar(ndarray)" args -> IO [NDArrayHandle]+_div_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_div_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_div_scalar_upd ::+                forall args . Fullfilled "_div_scalar(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_div_scalar(ndarray)" args -> IO ()+_div_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_div_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_div_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_backward_div_scalar ::+                     forall args . Fullfilled "_backward_div_scalar(ndarray)" args =>+                       ArgsHMap "_backward_div_scalar(ndarray)" args -> IO [NDArrayHandle]+_backward_div_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_div_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_div_scalar_upd ::+                         forall args . Fullfilled "_backward_div_scalar(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_div_scalar(ndarray)" args -> IO ()+_backward_div_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_div_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_rdiv_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_rdiv_scalar ::+             forall args . Fullfilled "_rdiv_scalar(ndarray)" args =>+               ArgsHMap "_rdiv_scalar(ndarray)" args -> IO [NDArrayHandle]+_rdiv_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rdiv_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_rdiv_scalar_upd ::+                 forall args . Fullfilled "_rdiv_scalar(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_rdiv_scalar(ndarray)" args -> IO ()+_rdiv_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rdiv_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_rdiv_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_rdiv_scalar ::+                      forall args . Fullfilled "_backward_rdiv_scalar(ndarray)" args =>+                        ArgsHMap "_backward_rdiv_scalar(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_rdiv_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rdiv_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_rdiv_scalar_upd ::+                          forall args . Fullfilled "_backward_rdiv_scalar(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_rdiv_scalar(ndarray)" args -> IO ()+_backward_rdiv_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rdiv_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_mod_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_mod_scalar ::+            forall args . Fullfilled "_mod_scalar(ndarray)" args =>+              ArgsHMap "_mod_scalar(ndarray)" args -> IO [NDArrayHandle]+_mod_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mod_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_mod_scalar_upd ::+                forall args . Fullfilled "_mod_scalar(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_mod_scalar(ndarray)" args -> IO ()+_mod_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mod_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_mod_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_mod_scalar ::+                     forall args . Fullfilled "_backward_mod_scalar(ndarray)" args =>+                       ArgsHMap "_backward_mod_scalar(ndarray)" args -> IO [NDArrayHandle]+_backward_mod_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mod_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_mod_scalar_upd ::+                         forall args . Fullfilled "_backward_mod_scalar(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_mod_scalar(ndarray)" args -> IO ()+_backward_mod_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mod_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_rmod_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_rmod_scalar ::+             forall args . Fullfilled "_rmod_scalar(ndarray)" args =>+               ArgsHMap "_rmod_scalar(ndarray)" args -> IO [NDArrayHandle]+_rmod_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rmod_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_rmod_scalar_upd ::+                 forall args . Fullfilled "_rmod_scalar(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_rmod_scalar(ndarray)" args -> IO ()+_rmod_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rmod_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_rmod_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_rmod_scalar ::+                      forall args . Fullfilled "_backward_rmod_scalar(ndarray)" args =>+                        ArgsHMap "_backward_rmod_scalar(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_rmod_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rmod_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_rmod_scalar_upd ::+                          forall args . Fullfilled "_backward_rmod_scalar(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_rmod_scalar(ndarray)" args -> IO ()+_backward_rmod_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rmod_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_ravel_multi_index(ndarray)" =+     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]++_ravel_multi_index ::+                   forall args . Fullfilled "_ravel_multi_index(ndarray)" args =>+                     ArgsHMap "_ravel_multi_index(ndarray)" args -> IO [NDArrayHandle]+_ravel_multi_index args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_ravel_multi_index"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_ravel_multi_index_upd ::+                       forall args . Fullfilled "_ravel_multi_index(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_ravel_multi_index(ndarray)" args -> IO ()+_ravel_multi_index_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_ravel_multi_index"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_unravel_index(ndarray)" =+     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]++_unravel_index ::+               forall args . Fullfilled "_unravel_index(ndarray)" args =>+                 ArgsHMap "_unravel_index(ndarray)" args -> IO [NDArrayHandle]+_unravel_index args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_unravel_index"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_unravel_index_upd ::+                   forall args . Fullfilled "_unravel_index(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_unravel_index(ndarray)" args -> IO ()+_unravel_index_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_unravel_index"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "argmax(ndarray)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),+        '("data", AttrOpt NDArrayHandle)]++argmax ::+       forall args . Fullfilled "argmax(ndarray)" args =>+         ArgsHMap "argmax(ndarray)" args -> IO [NDArrayHandle]+argmax args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++argmax_upd ::+           forall args . Fullfilled "argmax(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "argmax(ndarray)" args -> IO ()+argmax_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "argmin(ndarray)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),+        '("data", AttrOpt NDArrayHandle)]++argmin ::+       forall args . Fullfilled "argmin(ndarray)" args =>+         ArgsHMap "argmin(ndarray)" args -> IO [NDArrayHandle]+argmin args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++argmin_upd ::+           forall args . Fullfilled "argmin(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "argmin(ndarray)" args -> IO ()+argmin_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "argmax_channel(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++argmax_channel ::+               forall args . Fullfilled "argmax_channel(ndarray)" args =>+                 ArgsHMap "argmax_channel(ndarray)" args -> IO [NDArrayHandle]+argmax_channel args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmax_channel"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++argmax_channel_upd ::+                   forall args . Fullfilled "argmax_channel(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "argmax_channel(ndarray)" args -> IO ()+argmax_channel_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmax_channel"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "pick(ndarray)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),+        '("mode", AttrOpt (EnumType '["clip", "wrap"])),+        '("data", AttrOpt NDArrayHandle),+        '("index", AttrOpt NDArrayHandle)]++pick ::+     forall args . Fullfilled "pick(ndarray)" args =>+       ArgsHMap "pick(ndarray)" args -> IO [NDArrayHandle]+pick args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["clip", "wrap"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("index",) <$> (args !? #index :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "pick"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++pick_upd ::+         forall args . Fullfilled "pick(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "pick(ndarray)" args -> IO ()+pick_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["clip", "wrap"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("index",) <$> (args !? #index :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "pick"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_pick(ndarray)" = '[]++_backward_pick ::+               forall args . Fullfilled "_backward_pick(ndarray)" args =>+                 ArgsHMap "_backward_pick(ndarray)" args -> IO [NDArrayHandle]+_backward_pick args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_pick"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_pick_upd ::+                   forall args . Fullfilled "_backward_pick(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_pick(ndarray)" args -> IO ()+_backward_pick_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_pick"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_sparse_retain(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle),+        '("indices", AttrOpt NDArrayHandle)]++_sparse_retain ::+               forall args . Fullfilled "_sparse_retain(ndarray)" args =>+                 ArgsHMap "_sparse_retain(ndarray)" args -> IO [NDArrayHandle]+_sparse_retain args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sparse_retain"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sparse_retain_upd ::+                   forall args . Fullfilled "_sparse_retain(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_sparse_retain(ndarray)" args -> IO ()+_sparse_retain_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sparse_retain"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_sparse_retain(ndarray)" =+     '[]++_backward_sparse_retain ::+                        forall args . Fullfilled "_backward_sparse_retain(ndarray)" args =>+                          ArgsHMap "_backward_sparse_retain(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_sparse_retain args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sparse_retain"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_sparse_retain_upd ::+                            forall args . Fullfilled "_backward_sparse_retain(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_sparse_retain(ndarray)" args -> IO ()+_backward_sparse_retain_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sparse_retain"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_where(ndarray)" =+     '[ '("condition", AttrOpt NDArrayHandle),+        '("x", AttrOpt NDArrayHandle), '("y", AttrOpt NDArrayHandle)]++_where ::+       forall args . Fullfilled "_where(ndarray)" args =>+         ArgsHMap "_where(ndarray)" args -> IO [NDArrayHandle]+_where args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("condition",) <$> (args !? #condition :: Maybe NDArrayHandle),+               ("x",) <$> (args !? #x :: Maybe NDArrayHandle),+               ("y",) <$> (args !? #y :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "where"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_where_upd ::+           forall args . Fullfilled "_where(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "_where(ndarray)" args -> IO ()+_where_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("condition",) <$> (args !? #condition :: Maybe NDArrayHandle),+               ("x",) <$> (args !? #x :: Maybe NDArrayHandle),+               ("y",) <$> (args !? #y :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "where"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_where(ndarray)" = '[]++_backward_where ::+                forall args . Fullfilled "_backward_where(ndarray)" args =>+                  ArgsHMap "_backward_where(ndarray)" args -> IO [NDArrayHandle]+_backward_where args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_where"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_where_upd ::+                    forall args . Fullfilled "_backward_where(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_where(ndarray)" args -> IO ()+_backward_where_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_where"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "diag(ndarray)" =+     '[ '("k", AttrOpt (Maybe Int)), '("data", AttrOpt NDArrayHandle)]++diag ::+     forall args . Fullfilled "diag(ndarray)" args =>+       ArgsHMap "diag(ndarray)" args -> IO [NDArrayHandle]+diag args+  = let scalarArgs+          = catMaybes+              [("k",) . showValue <$> (args !? #k :: Maybe (Maybe Int))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "diag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++diag_upd ::+         forall args . Fullfilled "diag(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "diag(ndarray)" args -> IO ()+diag_upd outputs args+  = let scalarArgs+          = catMaybes+              [("k",) . showValue <$> (args !? #k :: Maybe (Maybe Int))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "diag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_diag(ndarray)" = '[]++_backward_diag ::+               forall args . Fullfilled "_backward_diag(ndarray)" args =>+                 ArgsHMap "_backward_diag(ndarray)" args -> IO [NDArrayHandle]+_backward_diag args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_diag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_diag_upd ::+                   forall args . Fullfilled "_backward_diag(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_diag(ndarray)" args -> IO ()+_backward_diag_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_diag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_maximum_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_maximum_scalar ::+                forall args . Fullfilled "_maximum_scalar(ndarray)" args =>+                  ArgsHMap "_maximum_scalar(ndarray)" args -> IO [NDArrayHandle]+_maximum_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_maximum_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_maximum_scalar_upd ::+                    forall args . Fullfilled "_maximum_scalar(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_maximum_scalar(ndarray)" args -> IO ()+_maximum_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_maximum_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_maximum_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_maximum_scalar ::+                         forall args .+                           Fullfilled "_backward_maximum_scalar(ndarray)" args =>+                           ArgsHMap "_backward_maximum_scalar(ndarray)" args ->+                             IO [NDArrayHandle]+_backward_maximum_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_maximum_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_maximum_scalar_upd ::+                             forall args .+                               Fullfilled "_backward_maximum_scalar(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_backward_maximum_scalar(ndarray)" args -> IO ()+_backward_maximum_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_maximum_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_minimum_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_minimum_scalar ::+                forall args . Fullfilled "_minimum_scalar(ndarray)" args =>+                  ArgsHMap "_minimum_scalar(ndarray)" args -> IO [NDArrayHandle]+_minimum_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minimum_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_minimum_scalar_upd ::+                    forall args . Fullfilled "_minimum_scalar(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_minimum_scalar(ndarray)" args -> IO ()+_minimum_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minimum_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_minimum_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_minimum_scalar ::+                         forall args .+                           Fullfilled "_backward_minimum_scalar(ndarray)" args =>+                           ArgsHMap "_backward_minimum_scalar(ndarray)" args ->+                             IO [NDArrayHandle]+_backward_minimum_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_minimum_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_minimum_scalar_upd ::+                             forall args .+                               Fullfilled "_backward_minimum_scalar(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_backward_minimum_scalar(ndarray)" args -> IO ()+_backward_minimum_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_minimum_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_power_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_power_scalar ::+              forall args . Fullfilled "_power_scalar(ndarray)" args =>+                ArgsHMap "_power_scalar(ndarray)" args -> IO [NDArrayHandle]+_power_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_power_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_power_scalar_upd ::+                  forall args . Fullfilled "_power_scalar(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_power_scalar(ndarray)" args -> IO ()+_power_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_power_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_power_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_power_scalar ::+                       forall args . Fullfilled "_backward_power_scalar(ndarray)" args =>+                         ArgsHMap "_backward_power_scalar(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_power_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_power_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_power_scalar_upd ::+                           forall args . Fullfilled "_backward_power_scalar(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_power_scalar(ndarray)" args -> IO ()+_backward_power_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_power_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_rpower_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_rpower_scalar ::+               forall args . Fullfilled "_rpower_scalar(ndarray)" args =>+                 ArgsHMap "_rpower_scalar(ndarray)" args -> IO [NDArrayHandle]+_rpower_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rpower_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_rpower_scalar_upd ::+                   forall args . Fullfilled "_rpower_scalar(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_rpower_scalar(ndarray)" args -> IO ()+_rpower_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rpower_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_rpower_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_rpower_scalar ::+                        forall args . Fullfilled "_backward_rpower_scalar(ndarray)" args =>+                          ArgsHMap "_backward_rpower_scalar(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_rpower_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rpower_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_rpower_scalar_upd ::+                            forall args . Fullfilled "_backward_rpower_scalar(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_rpower_scalar(ndarray)" args -> IO ()+_backward_rpower_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rpower_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_hypot_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_hypot_scalar ::+              forall args . Fullfilled "_hypot_scalar(ndarray)" args =>+                ArgsHMap "_hypot_scalar(ndarray)" args -> IO [NDArrayHandle]+_hypot_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_hypot_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_hypot_scalar_upd ::+                  forall args . Fullfilled "_hypot_scalar(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_hypot_scalar(ndarray)" args -> IO ()+_hypot_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_hypot_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_hypot_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_hypot_scalar ::+                       forall args . Fullfilled "_backward_hypot_scalar(ndarray)" args =>+                         ArgsHMap "_backward_hypot_scalar(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_hypot_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_hypot_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_hypot_scalar_upd ::+                           forall args . Fullfilled "_backward_hypot_scalar(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_hypot_scalar(ndarray)" args -> IO ()+_backward_hypot_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_hypot_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "smooth_l1(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++smooth_l1 ::+          forall args . Fullfilled "smooth_l1(ndarray)" args =>+            ArgsHMap "smooth_l1(ndarray)" args -> IO [NDArrayHandle]+smooth_l1 args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "smooth_l1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++smooth_l1_upd ::+              forall args . Fullfilled "smooth_l1(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "smooth_l1(ndarray)" args -> IO ()+smooth_l1_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "smooth_l1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_smooth_l1(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_smooth_l1 ::+                    forall args . Fullfilled "_backward_smooth_l1(ndarray)" args =>+                      ArgsHMap "_backward_smooth_l1(ndarray)" args -> IO [NDArrayHandle]+_backward_smooth_l1 args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_smooth_l1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_smooth_l1_upd ::+                        forall args . Fullfilled "_backward_smooth_l1(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_backward_smooth_l1(ndarray)" args -> IO ()+_backward_smooth_l1_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_smooth_l1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "topk(ndarray)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("k", AttrOpt Int),+        '("ret_typ",+          AttrOpt (EnumType '["both", "indices", "mask", "value"])),+        '("is_ascend", AttrOpt Bool),+        '("dtype",+          AttrOpt+            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),+        '("data", AttrOpt NDArrayHandle)]++topk ::+     forall args . Fullfilled "topk(ndarray)" args =>+       ArgsHMap "topk(ndarray)" args -> IO [NDArrayHandle]+topk args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("ret_typ",) . showValue <$>+                 (args !? #ret_typ ::+                    Maybe (EnumType '["both", "indices", "mask", "value"])),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "topk"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++topk_upd ::+         forall args . Fullfilled "topk(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "topk(ndarray)" args -> IO ()+topk_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("ret_typ",) . showValue <$>+                 (args !? #ret_typ ::+                    Maybe (EnumType '["both", "indices", "mask", "value"])),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "topk"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_topk(ndarray)" = '[]++_backward_topk ::+               forall args . Fullfilled "_backward_topk(ndarray)" args =>+                 ArgsHMap "_backward_topk(ndarray)" args -> IO [NDArrayHandle]+_backward_topk args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_topk"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_topk_upd ::+                   forall args . Fullfilled "_backward_topk(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_topk(ndarray)" args -> IO ()+_backward_topk_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_topk"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "sort(ndarray)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),+        '("data", AttrOpt NDArrayHandle)]++sort ::+     forall args . Fullfilled "sort(ndarray)" args =>+       ArgsHMap "sort(ndarray)" args -> IO [NDArrayHandle]+sort args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sort"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++sort_upd ::+         forall args . Fullfilled "sort(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "sort(ndarray)" args -> IO ()+sort_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sort"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "argsort(ndarray)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),+        '("dtype",+          AttrOpt+            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),+        '("data", AttrOpt NDArrayHandle)]++argsort ::+        forall args . Fullfilled "argsort(ndarray)" args =>+          ArgsHMap "argsort(ndarray)" args -> IO [NDArrayHandle]+argsort args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argsort"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++argsort_upd ::+            forall args . Fullfilled "argsort(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "argsort(ndarray)" args -> IO ()+argsort_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argsort"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Reshape(ndarray)" =+     '[ '("shape", AttrOpt [Int]), '("reverse", AttrOpt Bool),+        '("target_shape", AttrOpt [Int]), '("keep_highest", AttrOpt Bool),+        '("data", AttrOpt NDArrayHandle)]++_Reshape ::+         forall args . Fullfilled "_Reshape(ndarray)" args =>+           ArgsHMap "_Reshape(ndarray)" args -> IO [NDArrayHandle]+_Reshape args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("keep_highest",) . showValue <$>+                 (args !? #keep_highest :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Reshape"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Reshape_upd ::+             forall args . Fullfilled "_Reshape(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "_Reshape(ndarray)" args -> IO ()+_Reshape_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("keep_highest",) . showValue <$>+                 (args !? #keep_highest :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Reshape"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Flatten(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_Flatten ::+         forall args . Fullfilled "_Flatten(ndarray)" args =>+           ArgsHMap "_Flatten(ndarray)" args -> IO [NDArrayHandle]+_Flatten args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Flatten"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Flatten_upd ::+             forall args . Fullfilled "_Flatten(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "_Flatten(ndarray)" args -> IO ()+_Flatten_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Flatten"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "transpose(ndarray)" =+     '[ '("axes", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]++transpose ::+          forall args . Fullfilled "transpose(ndarray)" args =>+            ArgsHMap "transpose(ndarray)" args -> IO [NDArrayHandle]+transpose args+  = let scalarArgs+          = catMaybes+              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "transpose"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++transpose_upd ::+              forall args . Fullfilled "transpose(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "transpose(ndarray)" args -> IO ()+transpose_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "transpose"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "expand_dims(ndarray)" =+     '[ '("axis", AttrReq Int), '("data", AttrOpt NDArrayHandle)]++expand_dims ::+            forall args . Fullfilled "expand_dims(ndarray)" args =>+              ArgsHMap "expand_dims(ndarray)" args -> IO [NDArrayHandle]+expand_dims args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "expand_dims"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++expand_dims_upd ::+                forall args . Fullfilled "expand_dims(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "expand_dims(ndarray)" args -> IO ()+expand_dims_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "expand_dims"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "slice(ndarray)" =+     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),+        '("step", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]++slice ::+      forall args . Fullfilled "slice(ndarray)" args =>+        ArgsHMap "slice(ndarray)" args -> IO [NDArrayHandle]+slice args+  = let scalarArgs+          = catMaybes+              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "slice"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++slice_upd ::+          forall args . Fullfilled "slice(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "slice(ndarray)" args -> IO ()+slice_upd outputs args+  = let scalarArgs+          = catMaybes+              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "slice"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_slice(ndarray)" = '[]++_backward_slice ::+                forall args . Fullfilled "_backward_slice(ndarray)" args =>+                  ArgsHMap "_backward_slice(ndarray)" args -> IO [NDArrayHandle]+_backward_slice args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_slice"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_slice_upd ::+                    forall args . Fullfilled "_backward_slice(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_slice(ndarray)" args -> IO ()+_backward_slice_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_slice"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_slice_assign(ndarray)" =+     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),+        '("step", AttrOpt [Int]), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_slice_assign ::+              forall args . Fullfilled "_slice_assign(ndarray)" args =>+                ArgsHMap "_slice_assign(ndarray)" args -> IO [NDArrayHandle]+_slice_assign args+  = let scalarArgs+          = catMaybes+              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_slice_assign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_slice_assign_upd ::+                  forall args . Fullfilled "_slice_assign(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_slice_assign(ndarray)" args -> IO ()+_slice_assign_upd outputs args+  = let scalarArgs+          = catMaybes+              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_slice_assign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_slice_assign_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("begin", AttrReq [Int]),+        '("end", AttrReq [Int]), '("step", AttrOpt [Int]),+        '("data", AttrOpt NDArrayHandle)]++_slice_assign_scalar ::+                     forall args . Fullfilled "_slice_assign_scalar(ndarray)" args =>+                       ArgsHMap "_slice_assign_scalar(ndarray)" args -> IO [NDArrayHandle]+_slice_assign_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float),+               ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_slice_assign_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_slice_assign_scalar_upd ::+                         forall args . Fullfilled "_slice_assign_scalar(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_slice_assign_scalar(ndarray)" args -> IO ()+_slice_assign_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float),+               ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_slice_assign_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "slice_axis(ndarray)" =+     '[ '("axis", AttrReq Int), '("begin", AttrReq Int),+        '("end", AttrReq (Maybe Int)), '("data", AttrOpt NDArrayHandle)]++slice_axis ::+           forall args . Fullfilled "slice_axis(ndarray)" args =>+             ArgsHMap "slice_axis(ndarray)" args -> IO [NDArrayHandle]+slice_axis args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("begin",) . showValue <$> (args !? #begin :: Maybe Int),+               ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "slice_axis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++slice_axis_upd ::+               forall args . Fullfilled "slice_axis(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "slice_axis(ndarray)" args -> IO ()+slice_axis_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("begin",) . showValue <$> (args !? #begin :: Maybe Int),+               ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "slice_axis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_slice_axis(ndarray)" = '[]++_backward_slice_axis ::+                     forall args . Fullfilled "_backward_slice_axis(ndarray)" args =>+                       ArgsHMap "_backward_slice_axis(ndarray)" args -> IO [NDArrayHandle]+_backward_slice_axis args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_slice_axis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_slice_axis_upd ::+                         forall args . Fullfilled "_backward_slice_axis(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_slice_axis(ndarray)" args -> IO ()+_backward_slice_axis_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_slice_axis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "slice_like(ndarray)" =+     '[ '("axes", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle),+        '("shape_like", AttrOpt NDArrayHandle)]++slice_like ::+           forall args . Fullfilled "slice_like(ndarray)" args =>+             ArgsHMap "slice_like(ndarray)" args -> IO [NDArrayHandle]+slice_like args+  = let scalarArgs+          = catMaybes+              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("shape_like",) <$> (args !? #shape_like :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "slice_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++slice_like_upd ::+               forall args . Fullfilled "slice_like(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "slice_like(ndarray)" args -> IO ()+slice_like_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("shape_like",) <$> (args !? #shape_like :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "slice_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_slice_like(ndarray)" = '[]++_backward_slice_like ::+                     forall args . Fullfilled "_backward_slice_like(ndarray)" args =>+                       ArgsHMap "_backward_slice_like(ndarray)" args -> IO [NDArrayHandle]+_backward_slice_like args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_slice_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_slice_like_upd ::+                         forall args . Fullfilled "_backward_slice_like(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_slice_like(ndarray)" args -> IO ()+_backward_slice_like_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_slice_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "clip(ndarray)" =+     '[ '("a_min", AttrReq Float), '("a_max", AttrReq Float),+        '("data", AttrOpt NDArrayHandle)]++clip ::+     forall args . Fullfilled "clip(ndarray)" args =>+       ArgsHMap "clip(ndarray)" args -> IO [NDArrayHandle]+clip args+  = let scalarArgs+          = catMaybes+              [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float),+               ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "clip"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++clip_upd ::+         forall args . Fullfilled "clip(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "clip(ndarray)" args -> IO ()+clip_upd outputs args+  = let scalarArgs+          = catMaybes+              [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float),+               ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "clip"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_clip(ndarray)" = '[]++_backward_clip ::+               forall args . Fullfilled "_backward_clip(ndarray)" args =>+                 ArgsHMap "_backward_clip(ndarray)" args -> IO [NDArrayHandle]+_backward_clip args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_clip"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_clip_upd ::+                   forall args . Fullfilled "_backward_clip(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_clip(ndarray)" args -> IO ()+_backward_clip_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_clip"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "repeat(ndarray)" =+     '[ '("repeats", AttrReq Int), '("axis", AttrOpt (Maybe Int)),+        '("data", AttrOpt NDArrayHandle)]++repeat ::+       forall args . Fullfilled "repeat(ndarray)" args =>+         ArgsHMap "repeat(ndarray)" args -> IO [NDArrayHandle]+repeat args+  = let scalarArgs+          = catMaybes+              [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int),+               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "repeat"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++repeat_upd ::+           forall args . Fullfilled "repeat(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "repeat(ndarray)" args -> IO ()+repeat_upd outputs args+  = let scalarArgs+          = catMaybes+              [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int),+               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "repeat"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_repeat(ndarray)" = '[]++_backward_repeat ::+                 forall args . Fullfilled "_backward_repeat(ndarray)" args =>+                   ArgsHMap "_backward_repeat(ndarray)" args -> IO [NDArrayHandle]+_backward_repeat args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_repeat"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_repeat_upd ::+                     forall args . Fullfilled "_backward_repeat(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_backward_repeat(ndarray)" args -> IO ()+_backward_repeat_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_repeat"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "tile(ndarray)" =+     '[ '("reps", AttrReq [Int]), '("data", AttrOpt NDArrayHandle)]++tile ::+     forall args . Fullfilled "tile(ndarray)" args =>+       ArgsHMap "tile(ndarray)" args -> IO [NDArrayHandle]+tile args+  = let scalarArgs+          = catMaybes+              [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tile"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++tile_upd ::+         forall args . Fullfilled "tile(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "tile(ndarray)" args -> IO ()+tile_upd outputs args+  = let scalarArgs+          = catMaybes+              [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tile"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_tile(ndarray)" = '[]++_backward_tile ::+               forall args . Fullfilled "_backward_tile(ndarray)" args =>+                 ArgsHMap "_backward_tile(ndarray)" args -> IO [NDArrayHandle]+_backward_tile args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tile"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_tile_upd ::+                   forall args . Fullfilled "_backward_tile(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_tile(ndarray)" args -> IO ()+_backward_tile_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tile"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "reverse(ndarray)" =+     '[ '("axis", AttrReq [Int]), '("data", AttrOpt NDArrayHandle)]++reverse ::+        forall args . Fullfilled "reverse(ndarray)" args =>+          ArgsHMap "reverse(ndarray)" args -> IO [NDArrayHandle]+reverse args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reverse"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++reverse_upd ::+            forall args . Fullfilled "reverse(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "reverse(ndarray)" args -> IO ()+reverse_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reverse"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_reverse(ndarray)" = '[]++_backward_reverse ::+                  forall args . Fullfilled "_backward_reverse(ndarray)" args =>+                    ArgsHMap "_backward_reverse(ndarray)" args -> IO [NDArrayHandle]+_backward_reverse args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_reverse"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_reverse_upd ::+                      forall args . Fullfilled "_backward_reverse(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_reverse(ndarray)" args -> IO ()+_backward_reverse_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_reverse"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "stack(ndarray)" =+     '[ '("axis", AttrOpt Int), '("num_args", AttrReq Int),+        '("data", AttrOpt [NDArrayHandle])]++stack ::+      forall args . Fullfilled "stack(ndarray)" args =>+        ArgsHMap "stack(ndarray)" args -> IO [NDArrayHandle]+stack args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "stack"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        Nothing+         return listndarr++stack_upd ::+          forall args . Fullfilled "stack(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "stack(ndarray)" args -> IO ()+stack_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "stack"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        (Just outputs)+         return ()++type instance ParameterList "_backward_stack(ndarray)" = '[]++_backward_stack ::+                forall args . Fullfilled "_backward_stack(ndarray)" args =>+                  ArgsHMap "_backward_stack(ndarray)" args -> IO [NDArrayHandle]+_backward_stack args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_stack"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_stack_upd ::+                    forall args . Fullfilled "_backward_stack(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_stack(ndarray)" args -> IO ()+_backward_stack_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_stack"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "squeeze(ndarray)" =+     '[ '("axis", AttrOpt (Maybe [Int])),+        '("data", AttrOpt [NDArrayHandle])]++squeeze ::+        forall args . Fullfilled "squeeze(ndarray)" args =>+          ArgsHMap "squeeze(ndarray)" args -> IO [NDArrayHandle]+squeeze args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "squeeze"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++squeeze_upd ::+            forall args . Fullfilled "squeeze(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "squeeze(ndarray)" args -> IO ()+squeeze_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "squeeze"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_squeeze(ndarray)" = '[]++_backward_squeeze ::+                  forall args . Fullfilled "_backward_squeeze(ndarray)" args =>+                    ArgsHMap "_backward_squeeze(ndarray)" args -> IO [NDArrayHandle]+_backward_squeeze args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_squeeze"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_squeeze_upd ::+                      forall args . Fullfilled "_backward_squeeze(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_squeeze(ndarray)" args -> IO ()+_backward_squeeze_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_squeeze"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "depth_to_space(ndarray)" =+     '[ '("block_size", AttrReq Int), '("data", AttrOpt NDArrayHandle)]++depth_to_space ::+               forall args . Fullfilled "depth_to_space(ndarray)" args =>+                 ArgsHMap "depth_to_space(ndarray)" args -> IO [NDArrayHandle]+depth_to_space args+  = let scalarArgs+          = catMaybes+              [("block_size",) . showValue <$>+                 (args !? #block_size :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "depth_to_space"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++depth_to_space_upd ::+                   forall args . Fullfilled "depth_to_space(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "depth_to_space(ndarray)" args -> IO ()+depth_to_space_upd outputs args+  = let scalarArgs+          = catMaybes+              [("block_size",) . showValue <$>+                 (args !? #block_size :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "depth_to_space"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "space_to_depth(ndarray)" =+     '[ '("block_size", AttrReq Int), '("data", AttrOpt NDArrayHandle)]++space_to_depth ::+               forall args . Fullfilled "space_to_depth(ndarray)" args =>+                 ArgsHMap "space_to_depth(ndarray)" args -> IO [NDArrayHandle]+space_to_depth args+  = let scalarArgs+          = catMaybes+              [("block_size",) . showValue <$>+                 (args !? #block_size :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "space_to_depth"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++space_to_depth_upd ::+                   forall args . Fullfilled "space_to_depth(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "space_to_depth(ndarray)" args -> IO ()+space_to_depth_upd outputs args+  = let scalarArgs+          = catMaybes+              [("block_size",) . showValue <$>+                 (args !? #block_size :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "space_to_depth"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "dot(ndarray)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("forward_stype",+          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))),+        '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]++dot ::+    forall args . Fullfilled "dot(ndarray)" args =>+      ArgsHMap "dot(ndarray)" args -> IO [NDArrayHandle]+dot args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("forward_stype",) . showValue <$>+                 (args !? #forward_stype ::+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "dot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++dot_upd ::+        forall args . Fullfilled "dot(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "dot(ndarray)" args -> IO ()+dot_upd outputs args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("forward_stype",) . showValue <$>+                 (args !? #forward_stype ::+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "dot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_dot(ndarray)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("forward_stype",+          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"])))]++_backward_dot ::+              forall args . Fullfilled "_backward_dot(ndarray)" args =>+                ArgsHMap "_backward_dot(ndarray)" args -> IO [NDArrayHandle]+_backward_dot args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("forward_stype",) . showValue <$>+                 (args !? #forward_stype ::+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_dot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_dot_upd ::+                  forall args . Fullfilled "_backward_dot(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_dot(ndarray)" args -> IO ()+_backward_dot_upd outputs args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("forward_stype",) . showValue <$>+                 (args !? #forward_stype ::+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_dot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "batch_dot(ndarray)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("forward_stype",+          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))),+        '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]++batch_dot ::+          forall args . Fullfilled "batch_dot(ndarray)" args =>+            ArgsHMap "batch_dot(ndarray)" args -> IO [NDArrayHandle]+batch_dot args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("forward_stype",) . showValue <$>+                 (args !? #forward_stype ::+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "batch_dot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++batch_dot_upd ::+              forall args . Fullfilled "batch_dot(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "batch_dot(ndarray)" args -> IO ()+batch_dot_upd outputs args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("forward_stype",) . showValue <$>+                 (args !? #forward_stype ::+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "batch_dot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_batch_dot(ndarray)" = '[]++_backward_batch_dot ::+                    forall args . Fullfilled "_backward_batch_dot(ndarray)" args =>+                      ArgsHMap "_backward_batch_dot(ndarray)" args -> IO [NDArrayHandle]+_backward_batch_dot args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_batch_dot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_batch_dot_upd ::+                        forall args . Fullfilled "_backward_batch_dot(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_backward_batch_dot(ndarray)" args -> IO ()+_backward_batch_dot_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_batch_dot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "sin(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++sin ::+    forall args . Fullfilled "sin(ndarray)" args =>+      ArgsHMap "sin(ndarray)" args -> IO [NDArrayHandle]+sin args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++sin_upd ::+        forall args . Fullfilled "sin(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "sin(ndarray)" args -> IO ()+sin_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_sin(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_sin ::+              forall args . Fullfilled "_backward_sin(ndarray)" args =>+                ArgsHMap "_backward_sin(ndarray)" args -> IO [NDArrayHandle]+_backward_sin args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_sin_upd ::+                  forall args . Fullfilled "_backward_sin(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_sin(ndarray)" args -> IO ()+_backward_sin_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "cos(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++cos ::+    forall args . Fullfilled "cos(ndarray)" args =>+      ArgsHMap "cos(ndarray)" args -> IO [NDArrayHandle]+cos args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cos"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++cos_upd ::+        forall args . Fullfilled "cos(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "cos(ndarray)" args -> IO ()+cos_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cos"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_cos(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_cos ::+              forall args . Fullfilled "_backward_cos(ndarray)" args =>+                ArgsHMap "_backward_cos(ndarray)" args -> IO [NDArrayHandle]+_backward_cos args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cos"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_cos_upd ::+                  forall args . Fullfilled "_backward_cos(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_cos(ndarray)" args -> IO ()+_backward_cos_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cos"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "tan(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++tan ::+    forall args . Fullfilled "tan(ndarray)" args =>+      ArgsHMap "tan(ndarray)" args -> IO [NDArrayHandle]+tan args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tan"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++tan_upd ::+        forall args . Fullfilled "tan(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "tan(ndarray)" args -> IO ()+tan_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tan"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_tan(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_tan ::+              forall args . Fullfilled "_backward_tan(ndarray)" args =>+                ArgsHMap "_backward_tan(ndarray)" args -> IO [NDArrayHandle]+_backward_tan args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tan"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_tan_upd ::+                  forall args . Fullfilled "_backward_tan(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_tan(ndarray)" args -> IO ()+_backward_tan_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tan"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "arcsin(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++arcsin ::+       forall args . Fullfilled "arcsin(ndarray)" args =>+         ArgsHMap "arcsin(ndarray)" args -> IO [NDArrayHandle]+arcsin args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arcsin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++arcsin_upd ::+           forall args . Fullfilled "arcsin(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "arcsin(ndarray)" args -> IO ()+arcsin_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arcsin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_arcsin(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_arcsin ::+                 forall args . Fullfilled "_backward_arcsin(ndarray)" args =>+                   ArgsHMap "_backward_arcsin(ndarray)" args -> IO [NDArrayHandle]+_backward_arcsin args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arcsin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_arcsin_upd ::+                     forall args . Fullfilled "_backward_arcsin(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_backward_arcsin(ndarray)" args -> IO ()+_backward_arcsin_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arcsin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "arccos(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++arccos ::+       forall args . Fullfilled "arccos(ndarray)" args =>+         ArgsHMap "arccos(ndarray)" args -> IO [NDArrayHandle]+arccos args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arccos"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++arccos_upd ::+           forall args . Fullfilled "arccos(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "arccos(ndarray)" args -> IO ()+arccos_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arccos"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_arccos(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_arccos ::+                 forall args . Fullfilled "_backward_arccos(ndarray)" args =>+                   ArgsHMap "_backward_arccos(ndarray)" args -> IO [NDArrayHandle]+_backward_arccos args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arccos"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_arccos_upd ::+                     forall args . Fullfilled "_backward_arccos(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_backward_arccos(ndarray)" args -> IO ()+_backward_arccos_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arccos"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "arctan(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++arctan ::+       forall args . Fullfilled "arctan(ndarray)" args =>+         ArgsHMap "arctan(ndarray)" args -> IO [NDArrayHandle]+arctan args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arctan"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++arctan_upd ::+           forall args . Fullfilled "arctan(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "arctan(ndarray)" args -> IO ()+arctan_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arctan"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_arctan(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_arctan ::+                 forall args . Fullfilled "_backward_arctan(ndarray)" args =>+                   ArgsHMap "_backward_arctan(ndarray)" args -> IO [NDArrayHandle]+_backward_arctan args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arctan"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_arctan_upd ::+                     forall args . Fullfilled "_backward_arctan(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_backward_arctan(ndarray)" args -> IO ()+_backward_arctan_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arctan"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "degrees(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++degrees ::+        forall args . Fullfilled "degrees(ndarray)" args =>+          ArgsHMap "degrees(ndarray)" args -> IO [NDArrayHandle]+degrees args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "degrees"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++degrees_upd ::+            forall args . Fullfilled "degrees(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "degrees(ndarray)" args -> IO ()+degrees_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "degrees"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_degrees(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_degrees ::+                  forall args . Fullfilled "_backward_degrees(ndarray)" args =>+                    ArgsHMap "_backward_degrees(ndarray)" args -> IO [NDArrayHandle]+_backward_degrees args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_degrees"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_degrees_upd ::+                      forall args . Fullfilled "_backward_degrees(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_degrees(ndarray)" args -> IO ()+_backward_degrees_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_degrees"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "radians(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++radians ::+        forall args . Fullfilled "radians(ndarray)" args =>+          ArgsHMap "radians(ndarray)" args -> IO [NDArrayHandle]+radians args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "radians"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++radians_upd ::+            forall args . Fullfilled "radians(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "radians(ndarray)" args -> IO ()+radians_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "radians"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_radians(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_radians ::+                  forall args . Fullfilled "_backward_radians(ndarray)" args =>+                    ArgsHMap "_backward_radians(ndarray)" args -> IO [NDArrayHandle]+_backward_radians args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_radians"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_radians_upd ::+                      forall args . Fullfilled "_backward_radians(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_radians(ndarray)" args -> IO ()+_backward_radians_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_radians"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "sinh(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++sinh ::+     forall args . Fullfilled "sinh(ndarray)" args =>+       ArgsHMap "sinh(ndarray)" args -> IO [NDArrayHandle]+sinh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sinh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++sinh_upd ::+         forall args . Fullfilled "sinh(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "sinh(ndarray)" args -> IO ()+sinh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sinh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_sinh(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_sinh ::+               forall args . Fullfilled "_backward_sinh(ndarray)" args =>+                 ArgsHMap "_backward_sinh(ndarray)" args -> IO [NDArrayHandle]+_backward_sinh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sinh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_sinh_upd ::+                   forall args . Fullfilled "_backward_sinh(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_sinh(ndarray)" args -> IO ()+_backward_sinh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sinh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "cosh(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++cosh ::+     forall args . Fullfilled "cosh(ndarray)" args =>+       ArgsHMap "cosh(ndarray)" args -> IO [NDArrayHandle]+cosh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cosh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++cosh_upd ::+         forall args . Fullfilled "cosh(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "cosh(ndarray)" args -> IO ()+cosh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cosh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_cosh(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_cosh ::+               forall args . Fullfilled "_backward_cosh(ndarray)" args =>+                 ArgsHMap "_backward_cosh(ndarray)" args -> IO [NDArrayHandle]+_backward_cosh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cosh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_cosh_upd ::+                   forall args . Fullfilled "_backward_cosh(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_cosh(ndarray)" args -> IO ()+_backward_cosh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cosh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "tanh(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++tanh ::+     forall args . Fullfilled "tanh(ndarray)" args =>+       ArgsHMap "tanh(ndarray)" args -> IO [NDArrayHandle]+tanh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tanh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++tanh_upd ::+         forall args . Fullfilled "tanh(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "tanh(ndarray)" args -> IO ()+tanh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tanh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_tanh(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_tanh ::+               forall args . Fullfilled "_backward_tanh(ndarray)" args =>+                 ArgsHMap "_backward_tanh(ndarray)" args -> IO [NDArrayHandle]+_backward_tanh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tanh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_tanh_upd ::+                   forall args . Fullfilled "_backward_tanh(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_tanh(ndarray)" args -> IO ()+_backward_tanh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tanh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "arcsinh(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++arcsinh ::+        forall args . Fullfilled "arcsinh(ndarray)" args =>+          ArgsHMap "arcsinh(ndarray)" args -> IO [NDArrayHandle]+arcsinh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arcsinh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++arcsinh_upd ::+            forall args . Fullfilled "arcsinh(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "arcsinh(ndarray)" args -> IO ()+arcsinh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arcsinh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_arcsinh(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_arcsinh ::+                  forall args . Fullfilled "_backward_arcsinh(ndarray)" args =>+                    ArgsHMap "_backward_arcsinh(ndarray)" args -> IO [NDArrayHandle]+_backward_arcsinh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arcsinh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_arcsinh_upd ::+                      forall args . Fullfilled "_backward_arcsinh(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_arcsinh(ndarray)" args -> IO ()+_backward_arcsinh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arcsinh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "arccosh(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++arccosh ::+        forall args . Fullfilled "arccosh(ndarray)" args =>+          ArgsHMap "arccosh(ndarray)" args -> IO [NDArrayHandle]+arccosh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arccosh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++arccosh_upd ::+            forall args . Fullfilled "arccosh(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "arccosh(ndarray)" args -> IO ()+arccosh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arccosh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_arccosh(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_arccosh ::+                  forall args . Fullfilled "_backward_arccosh(ndarray)" args =>+                    ArgsHMap "_backward_arccosh(ndarray)" args -> IO [NDArrayHandle]+_backward_arccosh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arccosh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_arccosh_upd ::+                      forall args . Fullfilled "_backward_arccosh(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_arccosh(ndarray)" args -> IO ()+_backward_arccosh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arccosh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "arctanh(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++arctanh ::+        forall args . Fullfilled "arctanh(ndarray)" args =>+          ArgsHMap "arctanh(ndarray)" args -> IO [NDArrayHandle]+arctanh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arctanh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++arctanh_upd ::+            forall args . Fullfilled "arctanh(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "arctanh(ndarray)" args -> IO ()+arctanh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arctanh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_arctanh(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_arctanh ::+                  forall args . Fullfilled "_backward_arctanh(ndarray)" args =>+                    ArgsHMap "_backward_arctanh(ndarray)" args -> IO [NDArrayHandle]+_backward_arctanh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arctanh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_arctanh_upd ::+                      forall args . Fullfilled "_backward_arctanh(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_arctanh(ndarray)" args -> IO ()+_backward_arctanh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arctanh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_CTCLoss(ndarray)" =+     '[ '("use_data_lengths", AttrOpt Bool),+        '("use_label_lengths", AttrOpt Bool),+        '("blank_label", AttrOpt (EnumType '["first", "last"])),+        '("data", AttrOpt NDArrayHandle),+        '("label", AttrOpt NDArrayHandle),+        '("data_lengths", AttrOpt NDArrayHandle),+        '("label_lengths", AttrOpt NDArrayHandle)]++_contrib_CTCLoss ::+                 forall args . Fullfilled "_contrib_CTCLoss(ndarray)" args =>+                   ArgsHMap "_contrib_CTCLoss(ndarray)" args -> IO [NDArrayHandle]+_contrib_CTCLoss args+  = let scalarArgs+          = catMaybes+              [("use_data_lengths",) . showValue <$>+                 (args !? #use_data_lengths :: Maybe Bool),+               ("use_label_lengths",) . showValue <$>+                 (args !? #use_label_lengths :: Maybe Bool),+               ("blank_label",) . showValue <$>+                 (args !? #blank_label :: Maybe (EnumType '["first", "last"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle),+               ("data_lengths",) <$>+                 (args !? #data_lengths :: Maybe NDArrayHandle),+               ("label_lengths",) <$>+                 (args !? #label_lengths :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_CTCLoss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_CTCLoss_upd ::+                     forall args . Fullfilled "_contrib_CTCLoss(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_contrib_CTCLoss(ndarray)" args -> IO ()+_contrib_CTCLoss_upd outputs args+  = let scalarArgs+          = catMaybes+              [("use_data_lengths",) . showValue <$>+                 (args !? #use_data_lengths :: Maybe Bool),+               ("use_label_lengths",) . showValue <$>+                 (args !? #use_label_lengths :: Maybe Bool),+               ("blank_label",) . showValue <$>+                 (args !? #blank_label :: Maybe (EnumType '["first", "last"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle),+               ("data_lengths",) <$>+                 (args !? #data_lengths :: Maybe NDArrayHandle),+               ("label_lengths",) <$>+                 (args !? #label_lengths :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_CTCLoss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_quadratic(ndarray)" =+     '[ '("a", AttrOpt Float), '("b", AttrOpt Float),+        '("c", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_contrib_quadratic ::+                   forall args . Fullfilled "_contrib_quadratic(ndarray)" args =>+                     ArgsHMap "_contrib_quadratic(ndarray)" args -> IO [NDArrayHandle]+_contrib_quadratic args+  = let scalarArgs+          = catMaybes+              [("a",) . showValue <$> (args !? #a :: Maybe Float),+               ("b",) . showValue <$> (args !? #b :: Maybe Float),+               ("c",) . showValue <$> (args !? #c :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quadratic"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_quadratic_upd ::+                       forall args . Fullfilled "_contrib_quadratic(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_contrib_quadratic(ndarray)" args -> IO ()+_contrib_quadratic_upd outputs args+  = let scalarArgs+          = catMaybes+              [("a",) . showValue <$> (args !? #a :: Maybe Float),+               ("b",) . showValue <$> (args !? #b :: Maybe Float),+               ("c",) . showValue <$> (args !? #c :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quadratic"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_backward_quadratic(ndarray)"+     = '[]++_contrib_backward_quadratic ::+                            forall args .+                              Fullfilled "_contrib_backward_quadratic(ndarray)" args =>+                              ArgsHMap "_contrib_backward_quadratic(ndarray)" args ->+                                IO [NDArrayHandle]+_contrib_backward_quadratic args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_backward_quadratic"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_backward_quadratic_upd ::+                                forall args .+                                  Fullfilled "_contrib_backward_quadratic(ndarray)" args =>+                                  [NDArrayHandle] ->+                                    ArgsHMap "_contrib_backward_quadratic(ndarray)" args -> IO ()+_contrib_backward_quadratic_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_backward_quadratic"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_div_sqrt_dim(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_contrib_div_sqrt_dim ::+                      forall args . Fullfilled "_contrib_div_sqrt_dim(ndarray)" args =>+                        ArgsHMap "_contrib_div_sqrt_dim(ndarray)" args ->+                          IO [NDArrayHandle]+_contrib_div_sqrt_dim args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_div_sqrt_dim"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_div_sqrt_dim_upd ::+                          forall args . Fullfilled "_contrib_div_sqrt_dim(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_contrib_div_sqrt_dim(ndarray)" args -> IO ()+_contrib_div_sqrt_dim_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_div_sqrt_dim"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "khatri_rao(ndarray)" =+     '[ '("args", AttrOpt [NDArrayHandle])]++khatri_rao ::+           forall args . Fullfilled "khatri_rao(ndarray)" args =>+             ArgsHMap "khatri_rao(ndarray)" args -> IO [NDArrayHandle]+khatri_rao args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "khatri_rao"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        Nothing+         return listndarr++khatri_rao_upd ::+               forall args . Fullfilled "khatri_rao(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "khatri_rao(ndarray)" args -> IO ()+khatri_rao_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "khatri_rao"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_ROIAlign(ndarray)" =+     '[ '("pooled_size", AttrReq [Int]),+        '("spatial_scale", AttrReq Float), '("sample_ratio", AttrOpt Int),+        '("data", AttrOpt NDArrayHandle), '("rois", AttrOpt NDArrayHandle)]++_contrib_ROIAlign ::+                  forall args . Fullfilled "_contrib_ROIAlign(ndarray)" args =>+                    ArgsHMap "_contrib_ROIAlign(ndarray)" args -> IO [NDArrayHandle]+_contrib_ROIAlign args+  = let scalarArgs+          = catMaybes+              [("pooled_size",) . showValue <$>+                 (args !? #pooled_size :: Maybe [Int]),+               ("spatial_scale",) . showValue <$>+                 (args !? #spatial_scale :: Maybe Float),+               ("sample_ratio",) . showValue <$>+                 (args !? #sample_ratio :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_ROIAlign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_ROIAlign_upd ::+                      forall args . Fullfilled "_contrib_ROIAlign(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_contrib_ROIAlign(ndarray)" args -> IO ()+_contrib_ROIAlign_upd outputs args+  = let scalarArgs+          = catMaybes+              [("pooled_size",) . showValue <$>+                 (args !? #pooled_size :: Maybe [Int]),+               ("spatial_scale",) . showValue <$>+                 (args !? #spatial_scale :: Maybe Float),+               ("sample_ratio",) . showValue <$>+                 (args !? #sample_ratio :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_ROIAlign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_ROIAlign(ndarray)" = '[]++_backward_ROIAlign ::+                   forall args . Fullfilled "_backward_ROIAlign(ndarray)" args =>+                     ArgsHMap "_backward_ROIAlign(ndarray)" args -> IO [NDArrayHandle]+_backward_ROIAlign args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_ROIAlign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_ROIAlign_upd ::+                       forall args . Fullfilled "_backward_ROIAlign(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_backward_ROIAlign(ndarray)" args -> IO ()+_backward_ROIAlign_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_ROIAlign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_box_nms(ndarray)" =+     '[ '("overlap_thresh", AttrOpt Float),+        '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int),+        '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int),+        '("id_index", AttrOpt Int), '("force_suppress", AttrOpt Bool),+        '("in_format", AttrOpt (EnumType '["center", "corner"])),+        '("out_format", AttrOpt (EnumType '["center", "corner"])),+        '("data", AttrOpt NDArrayHandle)]++_contrib_box_nms ::+                 forall args . Fullfilled "_contrib_box_nms(ndarray)" args =>+                   ArgsHMap "_contrib_box_nms(ndarray)" args -> IO [NDArrayHandle]+_contrib_box_nms args+  = let scalarArgs+          = catMaybes+              [("overlap_thresh",) . showValue <$>+                 (args !? #overlap_thresh :: Maybe Float),+               ("valid_thresh",) . showValue <$>+                 (args !? #valid_thresh :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),+               ("coord_start",) . showValue <$>+                 (args !? #coord_start :: Maybe Int),+               ("score_index",) . showValue <$>+                 (args !? #score_index :: Maybe Int),+               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),+               ("force_suppress",) . showValue <$>+                 (args !? #force_suppress :: Maybe Bool),+               ("in_format",) . showValue <$>+                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),+               ("out_format",) . showValue <$>+                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_box_nms"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_box_nms_upd ::+                     forall args . Fullfilled "_contrib_box_nms(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_contrib_box_nms(ndarray)" args -> IO ()+_contrib_box_nms_upd outputs args+  = let scalarArgs+          = catMaybes+              [("overlap_thresh",) . showValue <$>+                 (args !? #overlap_thresh :: Maybe Float),+               ("valid_thresh",) . showValue <$>+                 (args !? #valid_thresh :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),+               ("coord_start",) . showValue <$>+                 (args !? #coord_start :: Maybe Int),+               ("score_index",) . showValue <$>+                 (args !? #score_index :: Maybe Int),+               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),+               ("force_suppress",) . showValue <$>+                 (args !? #force_suppress :: Maybe Bool),+               ("in_format",) . showValue <$>+                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),+               ("out_format",) . showValue <$>+                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_box_nms"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_contrib_box_nms(ndarray)" =+     '[ '("overlap_thresh", AttrOpt Float),+        '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int),+        '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int),+        '("id_index", AttrOpt Int), '("force_suppress", AttrOpt Bool),+        '("in_format", AttrOpt (EnumType '["center", "corner"])),+        '("out_format", AttrOpt (EnumType '["center", "corner"]))]++_backward_contrib_box_nms ::+                          forall args .+                            Fullfilled "_backward_contrib_box_nms(ndarray)" args =>+                            ArgsHMap "_backward_contrib_box_nms(ndarray)" args ->+                              IO [NDArrayHandle]+_backward_contrib_box_nms args+  = let scalarArgs+          = catMaybes+              [("overlap_thresh",) . showValue <$>+                 (args !? #overlap_thresh :: Maybe Float),+               ("valid_thresh",) . showValue <$>+                 (args !? #valid_thresh :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),+               ("coord_start",) . showValue <$>+                 (args !? #coord_start :: Maybe Int),+               ("score_index",) . showValue <$>+                 (args !? #score_index :: Maybe Int),+               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),+               ("force_suppress",) . showValue <$>+                 (args !? #force_suppress :: Maybe Bool),+               ("in_format",) . showValue <$>+                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),+               ("out_format",) . showValue <$>+                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_box_nms"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_contrib_box_nms_upd ::+                              forall args .+                                Fullfilled "_backward_contrib_box_nms(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_backward_contrib_box_nms(ndarray)" args -> IO ()+_backward_contrib_box_nms_upd outputs args+  = let scalarArgs+          = catMaybes+              [("overlap_thresh",) . showValue <$>+                 (args !? #overlap_thresh :: Maybe Float),+               ("valid_thresh",) . showValue <$>+                 (args !? #valid_thresh :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),+               ("coord_start",) . showValue <$>+                 (args !? #coord_start :: Maybe Int),+               ("score_index",) . showValue <$>+                 (args !? #score_index :: Maybe Int),+               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),+               ("force_suppress",) . showValue <$>+                 (args !? #force_suppress :: Maybe Bool),+               ("in_format",) . showValue <$>+                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),+               ("out_format",) . showValue <$>+                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_box_nms"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_box_iou(ndarray)" =+     '[ '("format", AttrOpt (EnumType '["center", "corner"])),+        '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]++_contrib_box_iou ::+                 forall args . Fullfilled "_contrib_box_iou(ndarray)" args =>+                   ArgsHMap "_contrib_box_iou(ndarray)" args -> IO [NDArrayHandle]+_contrib_box_iou args+  = let scalarArgs+          = catMaybes+              [("format",) . showValue <$>+                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_box_iou"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_box_iou_upd ::+                     forall args . Fullfilled "_contrib_box_iou(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_contrib_box_iou(ndarray)" args -> IO ()+_contrib_box_iou_upd outputs args+  = let scalarArgs+          = catMaybes+              [("format",) . showValue <$>+                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_box_iou"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_contrib_box_iou(ndarray)" =+     '[ '("format", AttrOpt (EnumType '["center", "corner"]))]++_backward_contrib_box_iou ::+                          forall args .+                            Fullfilled "_backward_contrib_box_iou(ndarray)" args =>+                            ArgsHMap "_backward_contrib_box_iou(ndarray)" args ->+                              IO [NDArrayHandle]+_backward_contrib_box_iou args+  = let scalarArgs+          = catMaybes+              [("format",) . showValue <$>+                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_box_iou"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_contrib_box_iou_upd ::+                              forall args .+                                Fullfilled "_backward_contrib_box_iou(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_backward_contrib_box_iou(ndarray)" args -> IO ()+_backward_contrib_box_iou_upd outputs args+  = let scalarArgs+          = catMaybes+              [("format",) . showValue <$>+                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_box_iou"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_bipartite_matching(ndarray)"+     =+     '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float),+        '("topk", AttrOpt Int), '("data", AttrOpt NDArrayHandle)]++_contrib_bipartite_matching ::+                            forall args .+                              Fullfilled "_contrib_bipartite_matching(ndarray)" args =>+                              ArgsHMap "_contrib_bipartite_matching(ndarray)" args ->+                                IO [NDArrayHandle]+_contrib_bipartite_matching args+  = let scalarArgs+          = catMaybes+              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_bipartite_matching"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_bipartite_matching_upd ::+                                forall args .+                                  Fullfilled "_contrib_bipartite_matching(ndarray)" args =>+                                  [NDArrayHandle] ->+                                    ArgsHMap "_contrib_bipartite_matching(ndarray)" args -> IO ()+_contrib_bipartite_matching_upd outputs args+  = let scalarArgs+          = catMaybes+              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_bipartite_matching"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward_contrib_bipartite_matching(ndarray)" =+     '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float),+        '("topk", AttrOpt Int)]++_backward_contrib_bipartite_matching ::+                                     forall args .+                                       Fullfilled "_backward_contrib_bipartite_matching(ndarray)"+                                         args =>+                                       ArgsHMap "_backward_contrib_bipartite_matching(ndarray)" args+                                         -> IO [NDArrayHandle]+_backward_contrib_bipartite_matching args+  = let scalarArgs+          = catMaybes+              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_bipartite_matching"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_contrib_bipartite_matching_upd ::+                                         forall args .+                                           Fullfilled+                                             "_backward_contrib_bipartite_matching(ndarray)" args =>+                                           [NDArrayHandle] ->+                                             ArgsHMap+                                               "_backward_contrib_bipartite_matching(ndarray)"+                                               args+                                               -> IO ()+_backward_contrib_bipartite_matching_upd outputs args+  = let scalarArgs+          = catMaybes+              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_bipartite_matching"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_BilinearResize2D(ndarray)" =+     '[ '("height", AttrReq Int), '("width", AttrReq Int),+        '("data", AttrOpt NDArrayHandle)]++_contrib_BilinearResize2D ::+                          forall args .+                            Fullfilled "_contrib_BilinearResize2D(ndarray)" args =>+                            ArgsHMap "_contrib_BilinearResize2D(ndarray)" args ->+                              IO [NDArrayHandle]+_contrib_BilinearResize2D args+  = let scalarArgs+          = catMaybes+              [("height",) . showValue <$> (args !? #height :: Maybe Int),+               ("width",) . showValue <$> (args !? #width :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_BilinearResize2D"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_BilinearResize2D_upd ::+                              forall args .+                                Fullfilled "_contrib_BilinearResize2D(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_contrib_BilinearResize2D(ndarray)" args -> IO ()+_contrib_BilinearResize2D_upd outputs args+  = let scalarArgs+          = catMaybes+              [("height",) . showValue <$> (args !? #height :: Maybe Int),+               ("width",) . showValue <$> (args !? #width :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_BilinearResize2D"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward_contrib_BilinearResize2D(ndarray)" = '[]++_backward_contrib_BilinearResize2D ::+                                   forall args .+                                     Fullfilled "_backward_contrib_BilinearResize2D(ndarray)"+                                       args =>+                                     ArgsHMap "_backward_contrib_BilinearResize2D(ndarray)" args ->+                                       IO [NDArrayHandle]+_backward_contrib_BilinearResize2D args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_BilinearResize2D"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_contrib_BilinearResize2D_upd ::+                                       forall args .+                                         Fullfilled "_backward_contrib_BilinearResize2D(ndarray)"+                                           args =>+                                         [NDArrayHandle] ->+                                           ArgsHMap "_backward_contrib_BilinearResize2D(ndarray)"+                                             args+                                             -> IO ()+_backward_contrib_BilinearResize2D_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_BilinearResize2D"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_SyncBatchNorm(ndarray)" =+     '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float),+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),+        '("output_mean_var", AttrOpt Bool), '("ndev", AttrOpt Int),+        '("key", AttrOpt String), '("data", AttrOpt NDArrayHandle),+        '("gamma", AttrOpt NDArrayHandle),+        '("beta", AttrOpt NDArrayHandle),+        '("moving_mean", AttrOpt NDArrayHandle),+        '("moving_var", AttrOpt NDArrayHandle)]++_contrib_SyncBatchNorm ::+                       forall args . Fullfilled "_contrib_SyncBatchNorm(ndarray)" args =>+                         ArgsHMap "_contrib_SyncBatchNorm(ndarray)" args ->+                           IO [NDArrayHandle]+_contrib_SyncBatchNorm args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool),+               ("ndev",) . showValue <$> (args !? #ndev :: Maybe Int),+               ("key",) . showValue <$> (args !? #key :: Maybe String)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),+               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),+               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_SyncBatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_SyncBatchNorm_upd ::+                           forall args . Fullfilled "_contrib_SyncBatchNorm(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_contrib_SyncBatchNorm(ndarray)" args -> IO ()+_contrib_SyncBatchNorm_upd outputs args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool),+               ("ndev",) . showValue <$> (args !? #ndev :: Maybe Int),+               ("key",) . showValue <$> (args !? #key :: Maybe String)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),+               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),+               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_SyncBatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_contrib_AdaptiveAvgPooling2D(ndarray)" =+     '[ '("output_size", AttrOpt [Int]),+        '("data", AttrOpt NDArrayHandle)]++_contrib_AdaptiveAvgPooling2D ::+                              forall args .+                                Fullfilled "_contrib_AdaptiveAvgPooling2D(ndarray)" args =>+                                ArgsHMap "_contrib_AdaptiveAvgPooling2D(ndarray)" args ->+                                  IO [NDArrayHandle]+_contrib_AdaptiveAvgPooling2D args+  = let scalarArgs+          = catMaybes+              [("output_size",) . showValue <$>+                 (args !? #output_size :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_AdaptiveAvgPooling2D"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_AdaptiveAvgPooling2D_upd ::+                                  forall args .+                                    Fullfilled "_contrib_AdaptiveAvgPooling2D(ndarray)" args =>+                                    [NDArrayHandle] ->+                                      ArgsHMap "_contrib_AdaptiveAvgPooling2D(ndarray)" args ->+                                        IO ()+_contrib_AdaptiveAvgPooling2D_upd outputs args+  = let scalarArgs+          = catMaybes+              [("output_size",) . showValue <$>+                 (args !? #output_size :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_AdaptiveAvgPooling2D"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward_contrib_AdaptiveAvgPooling2D(ndarray)" =+     '[]++_backward_contrib_AdaptiveAvgPooling2D ::+                                       forall args .+                                         Fullfilled+                                           "_backward_contrib_AdaptiveAvgPooling2D(ndarray)" args =>+                                         ArgsHMap "_backward_contrib_AdaptiveAvgPooling2D(ndarray)"+                                           args+                                           -> IO [NDArrayHandle]+_backward_contrib_AdaptiveAvgPooling2D args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_AdaptiveAvgPooling2D"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_contrib_AdaptiveAvgPooling2D_upd ::+                                           forall args .+                                             Fullfilled+                                               "_backward_contrib_AdaptiveAvgPooling2D(ndarray)"+                                               args =>+                                             [NDArrayHandle] ->+                                               ArgsHMap+                                                 "_backward_contrib_AdaptiveAvgPooling2D(ndarray)"+                                                 args+                                                 -> IO ()+_backward_contrib_AdaptiveAvgPooling2D_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_AdaptiveAvgPooling2D"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_to_tensor(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_image_to_tensor ::+                 forall args . Fullfilled "_image_to_tensor(ndarray)" args =>+                   ArgsHMap "_image_to_tensor(ndarray)" args -> IO [NDArrayHandle]+_image_to_tensor args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_to_tensor"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_to_tensor_upd ::+                     forall args . Fullfilled "_image_to_tensor(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_image_to_tensor(ndarray)" args -> IO ()+_image_to_tensor_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_to_tensor"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_normalize(ndarray)" =+     '[ '("mean", AttrReq [Float]), '("std", AttrReq [Float]),+        '("data", AttrOpt NDArrayHandle)]++_image_normalize ::+                 forall args . Fullfilled "_image_normalize(ndarray)" args =>+                   ArgsHMap "_image_normalize(ndarray)" args -> IO [NDArrayHandle]+_image_normalize args+  = let scalarArgs+          = catMaybes+              [("mean",) . showValue <$> (args !? #mean :: Maybe [Float]),+               ("std",) . showValue <$> (args !? #std :: Maybe [Float])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_normalize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_normalize_upd ::+                     forall args . Fullfilled "_image_normalize(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_image_normalize(ndarray)" args -> IO ()+_image_normalize_upd outputs args+  = let scalarArgs+          = catMaybes+              [("mean",) . showValue <$> (args !? #mean :: Maybe [Float]),+               ("std",) . showValue <$> (args !? #std :: Maybe [Float])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_normalize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_flip_left_right(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_image_flip_left_right ::+                       forall args . Fullfilled "_image_flip_left_right(ndarray)" args =>+                         ArgsHMap "_image_flip_left_right(ndarray)" args ->+                           IO [NDArrayHandle]+_image_flip_left_right args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_flip_left_right"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_flip_left_right_upd ::+                           forall args . Fullfilled "_image_flip_left_right(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_image_flip_left_right(ndarray)" args -> IO ()+_image_flip_left_right_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_flip_left_right"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_image_random_flip_left_right(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_image_random_flip_left_right ::+                              forall args .+                                Fullfilled "_image_random_flip_left_right(ndarray)" args =>+                                ArgsHMap "_image_random_flip_left_right(ndarray)" args ->+                                  IO [NDArrayHandle]+_image_random_flip_left_right args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_flip_left_right"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_random_flip_left_right_upd ::+                                  forall args .+                                    Fullfilled "_image_random_flip_left_right(ndarray)" args =>+                                    [NDArrayHandle] ->+                                      ArgsHMap "_image_random_flip_left_right(ndarray)" args ->+                                        IO ()+_image_random_flip_left_right_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_flip_left_right"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_flip_top_bottom(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_image_flip_top_bottom ::+                       forall args . Fullfilled "_image_flip_top_bottom(ndarray)" args =>+                         ArgsHMap "_image_flip_top_bottom(ndarray)" args ->+                           IO [NDArrayHandle]+_image_flip_top_bottom args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_flip_top_bottom"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_flip_top_bottom_upd ::+                           forall args . Fullfilled "_image_flip_top_bottom(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_image_flip_top_bottom(ndarray)" args -> IO ()+_image_flip_top_bottom_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_flip_top_bottom"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_image_random_flip_top_bottom(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_image_random_flip_top_bottom ::+                              forall args .+                                Fullfilled "_image_random_flip_top_bottom(ndarray)" args =>+                                ArgsHMap "_image_random_flip_top_bottom(ndarray)" args ->+                                  IO [NDArrayHandle]+_image_random_flip_top_bottom args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_flip_top_bottom"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_random_flip_top_bottom_upd ::+                                  forall args .+                                    Fullfilled "_image_random_flip_top_bottom(ndarray)" args =>+                                    [NDArrayHandle] ->+                                      ArgsHMap "_image_random_flip_top_bottom(ndarray)" args ->+                                        IO ()+_image_random_flip_top_bottom_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_flip_top_bottom"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_random_brightness(ndarray)" =+     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),+        '("data", AttrOpt NDArrayHandle)]++_image_random_brightness ::+                         forall args .+                           Fullfilled "_image_random_brightness(ndarray)" args =>+                           ArgsHMap "_image_random_brightness(ndarray)" args ->+                             IO [NDArrayHandle]+_image_random_brightness args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_brightness"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_random_brightness_upd ::+                             forall args .+                               Fullfilled "_image_random_brightness(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_image_random_brightness(ndarray)" args -> IO ()+_image_random_brightness_upd outputs args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_brightness"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_random_contrast(ndarray)" =+     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),+        '("data", AttrOpt NDArrayHandle)]++_image_random_contrast ::+                       forall args . Fullfilled "_image_random_contrast(ndarray)" args =>+                         ArgsHMap "_image_random_contrast(ndarray)" args ->+                           IO [NDArrayHandle]+_image_random_contrast args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_contrast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_random_contrast_upd ::+                           forall args . Fullfilled "_image_random_contrast(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_image_random_contrast(ndarray)" args -> IO ()+_image_random_contrast_upd outputs args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_contrast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_random_saturation(ndarray)" =+     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),+        '("data", AttrOpt NDArrayHandle)]++_image_random_saturation ::+                         forall args .+                           Fullfilled "_image_random_saturation(ndarray)" args =>+                           ArgsHMap "_image_random_saturation(ndarray)" args ->+                             IO [NDArrayHandle]+_image_random_saturation args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_saturation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_random_saturation_upd ::+                             forall args .+                               Fullfilled "_image_random_saturation(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_image_random_saturation(ndarray)" args -> IO ()+_image_random_saturation_upd outputs args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_saturation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_random_hue(ndarray)" =+     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),+        '("data", AttrOpt NDArrayHandle)]++_image_random_hue ::+                  forall args . Fullfilled "_image_random_hue(ndarray)" args =>+                    ArgsHMap "_image_random_hue(ndarray)" args -> IO [NDArrayHandle]+_image_random_hue args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_hue"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_random_hue_upd ::+                      forall args . Fullfilled "_image_random_hue(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_image_random_hue(ndarray)" args -> IO ()+_image_random_hue_upd outputs args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_hue"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_random_color_jitter(ndarray)" =+     '[ '("brightness", AttrReq Float), '("contrast", AttrReq Float),+        '("saturation", AttrReq Float), '("hue", AttrReq Float),+        '("data", AttrOpt NDArrayHandle)]++_image_random_color_jitter ::+                           forall args .+                             Fullfilled "_image_random_color_jitter(ndarray)" args =>+                             ArgsHMap "_image_random_color_jitter(ndarray)" args ->+                               IO [NDArrayHandle]+_image_random_color_jitter args+  = let scalarArgs+          = catMaybes+              [("brightness",) . showValue <$>+                 (args !? #brightness :: Maybe Float),+               ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float),+               ("saturation",) . showValue <$>+                 (args !? #saturation :: Maybe Float),+               ("hue",) . showValue <$> (args !? #hue :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_color_jitter"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_random_color_jitter_upd ::+                               forall args .+                                 Fullfilled "_image_random_color_jitter(ndarray)" args =>+                                 [NDArrayHandle] ->+                                   ArgsHMap "_image_random_color_jitter(ndarray)" args -> IO ()+_image_random_color_jitter_upd outputs args+  = let scalarArgs+          = catMaybes+              [("brightness",) . showValue <$>+                 (args !? #brightness :: Maybe Float),+               ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float),+               ("saturation",) . showValue <$>+                 (args !? #saturation :: Maybe Float),+               ("hue",) . showValue <$> (args !? #hue :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_color_jitter"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_adjust_lighting(ndarray)" =+     '[ '("alpha", AttrReq [Float]), '("data", AttrOpt NDArrayHandle)]++_image_adjust_lighting ::+                       forall args . Fullfilled "_image_adjust_lighting(ndarray)" args =>+                         ArgsHMap "_image_adjust_lighting(ndarray)" args ->+                           IO [NDArrayHandle]+_image_adjust_lighting args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe [Float])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_adjust_lighting"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_adjust_lighting_upd ::+                           forall args . Fullfilled "_image_adjust_lighting(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_image_adjust_lighting(ndarray)" args -> IO ()+_image_adjust_lighting_upd outputs args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe [Float])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_adjust_lighting"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_random_lighting(ndarray)" =+     '[ '("alpha_std", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_image_random_lighting ::+                       forall args . Fullfilled "_image_random_lighting(ndarray)" args =>+                         ArgsHMap "_image_random_lighting(ndarray)" args ->+                           IO [NDArrayHandle]+_image_random_lighting args+  = let scalarArgs+          = catMaybes+              [("alpha_std",) . showValue <$>+                 (args !? #alpha_std :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_lighting"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_random_lighting_upd ::+                           forall args . Fullfilled "_image_random_lighting(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_image_random_lighting(ndarray)" args -> IO ()+_image_random_lighting_upd outputs args+  = let scalarArgs+          = catMaybes+              [("alpha_std",) . showValue <$>+                 (args !? #alpha_std :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_lighting"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "softmax(ndarray)" =+     '[ '("axis", AttrOpt Int),+        '("temperature", AttrOpt (Maybe Double)),+        '("data", AttrOpt NDArrayHandle)]++softmax ::+        forall args . Fullfilled "softmax(ndarray)" args =>+          ArgsHMap "softmax(ndarray)" args -> IO [NDArrayHandle]+softmax args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("temperature",) . showValue <$>+                 (args !? #temperature :: Maybe (Maybe Double))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++softmax_upd ::+            forall args . Fullfilled "softmax(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "softmax(ndarray)" args -> IO ()+softmax_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("temperature",) . showValue <$>+                 (args !? #temperature :: Maybe (Maybe Double))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_softmax(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_softmax ::+                  forall args . Fullfilled "_backward_softmax(ndarray)" args =>+                    ArgsHMap "_backward_softmax(ndarray)" args -> IO [NDArrayHandle]+_backward_softmax args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_softmax_upd ::+                      forall args . Fullfilled "_backward_softmax(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_softmax(ndarray)" args -> IO ()+_backward_softmax_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "log_softmax(ndarray)" =+     '[ '("axis", AttrOpt Int),+        '("temperature", AttrOpt (Maybe Double)),+        '("data", AttrOpt NDArrayHandle)]++log_softmax ::+            forall args . Fullfilled "log_softmax(ndarray)" args =>+              ArgsHMap "log_softmax(ndarray)" args -> IO [NDArrayHandle]+log_softmax args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("temperature",) . showValue <$>+                 (args !? #temperature :: Maybe (Maybe Double))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log_softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++log_softmax_upd ::+                forall args . Fullfilled "log_softmax(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "log_softmax(ndarray)" args -> IO ()+log_softmax_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("temperature",) . showValue <$>+                 (args !? #temperature :: Maybe (Maybe Double))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log_softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_log_softmax(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_log_softmax ::+                      forall args . Fullfilled "_backward_log_softmax(ndarray)" args =>+                        ArgsHMap "_backward_log_softmax(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_log_softmax args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log_softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_log_softmax_upd ::+                          forall args . Fullfilled "_backward_log_softmax(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_log_softmax(ndarray)" args -> IO ()+_backward_log_softmax_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log_softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Pooling(ndarray)" =+     '[ '("kernel", AttrOpt [Int]),+        '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])),+        '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool),+        '("pooling_convention", AttrOpt (EnumType '["full", "valid"])),+        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("p_value", AttrOpt (Maybe Int)),+        '("count_include_pad", AttrOpt (Maybe Bool)),+        '("data", AttrOpt NDArrayHandle)]++_Pooling ::+         forall args . Fullfilled "_Pooling(ndarray)" args =>+           ArgsHMap "_Pooling(ndarray)" args -> IO [NDArrayHandle]+_Pooling args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("pool_type",) . showValue <$>+                 (args !? #pool_type ::+                    Maybe (EnumType '["avg", "lp", "max", "sum"])),+               ("global_pool",) . showValue <$>+                 (args !? #global_pool :: Maybe Bool),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("pooling_convention",) . showValue <$>+                 (args !? #pooling_convention ::+                    Maybe (EnumType '["full", "valid"])),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("p_value",) . showValue <$>+                 (args !? #p_value :: Maybe (Maybe Int)),+               ("count_include_pad",) . showValue <$>+                 (args !? #count_include_pad :: Maybe (Maybe Bool))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Pooling_upd ::+             forall args . Fullfilled "_Pooling(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "_Pooling(ndarray)" args -> IO ()+_Pooling_upd outputs args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("pool_type",) . showValue <$>+                 (args !? #pool_type ::+                    Maybe (EnumType '["avg", "lp", "max", "sum"])),+               ("global_pool",) . showValue <$>+                 (args !? #global_pool :: Maybe Bool),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("pooling_convention",) . showValue <$>+                 (args !? #pooling_convention ::+                    Maybe (EnumType '["full", "valid"])),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("p_value",) . showValue <$>+                 (args !? #p_value :: Maybe (Maybe Int)),+               ("count_include_pad",) . showValue <$>+                 (args !? #count_include_pad :: Maybe (Maybe Bool))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Pooling(ndarray)" = '[]++_backward_Pooling ::+                  forall args . Fullfilled "_backward_Pooling(ndarray)" args =>+                    ArgsHMap "_backward_Pooling(ndarray)" args -> IO [NDArrayHandle]+_backward_Pooling args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Pooling_upd ::+                      forall args . Fullfilled "_backward_Pooling(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_Pooling(ndarray)" args -> IO ()+_backward_Pooling_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Deconvolution(ndarray)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("adj", AttrOpt [Int]), '("target_shape", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("cudnn_tune",+          AttrOpt+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+        '("cudnn_off", AttrOpt Bool),+        '("layout",+          AttrOpt+            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),+        '("data", AttrOpt NDArrayHandle),+        '("weight", AttrOpt NDArrayHandle),+        '("bias", AttrOpt NDArrayHandle)]++_Deconvolution ::+               forall args . Fullfilled "_Deconvolution(ndarray)" args =>+                 ArgsHMap "_Deconvolution(ndarray)" args -> IO [NDArrayHandle]+_Deconvolution args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Deconvolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Deconvolution_upd ::+                   forall args . Fullfilled "_Deconvolution(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_Deconvolution(ndarray)" args -> IO ()+_Deconvolution_upd outputs args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Deconvolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Deconvolution(ndarray)" =+     '[]++_backward_Deconvolution ::+                        forall args . Fullfilled "_backward_Deconvolution(ndarray)" args =>+                          ArgsHMap "_backward_Deconvolution(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_Deconvolution args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Deconvolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Deconvolution_upd ::+                            forall args . Fullfilled "_backward_Deconvolution(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_Deconvolution(ndarray)" args -> IO ()+_backward_Deconvolution_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Deconvolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Activation(ndarray)" =+     '[ '("act_type",+          AttrReq+            (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"])),+        '("data", AttrOpt NDArrayHandle)]++_Activation ::+            forall args . Fullfilled "_Activation(ndarray)" args =>+              ArgsHMap "_Activation(ndarray)" args -> IO [NDArrayHandle]+_Activation args+  = let scalarArgs+          = catMaybes+              [("act_type",) . showValue <$>+                 (args !? #act_type ::+                    Maybe+                      (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Activation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Activation_upd ::+                forall args . Fullfilled "_Activation(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_Activation(ndarray)" args -> IO ()+_Activation_upd outputs args+  = let scalarArgs+          = catMaybes+              [("act_type",) . showValue <$>+                 (args !? #act_type ::+                    Maybe+                      (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Activation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Activation(ndarray)" = '[]++_backward_Activation ::+                     forall args . Fullfilled "_backward_Activation(ndarray)" args =>+                       ArgsHMap "_backward_Activation(ndarray)" args -> IO [NDArrayHandle]+_backward_Activation args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Activation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Activation_upd ::+                         forall args . Fullfilled "_backward_Activation(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_Activation(ndarray)" args -> IO ()+_backward_Activation_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Activation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_UpSampling(ndarray)" =+     '[ '("scale", AttrReq Int), '("num_filter", AttrOpt Int),+        '("sample_type", AttrReq (EnumType '["bilinear", "nearest"])),+        '("multi_input_mode", AttrOpt (EnumType '["concat", "sum"])),+        '("num_args", AttrReq Int), '("workspace", AttrOpt Int),+        '("data", AttrOpt [NDArrayHandle])]++_UpSampling ::+            forall args . Fullfilled "_UpSampling(ndarray)" args =>+              ArgsHMap "_UpSampling(ndarray)" args -> IO [NDArrayHandle]+_UpSampling args+  = let scalarArgs+          = catMaybes+              [("scale",) . showValue <$> (args !? #scale :: Maybe Int),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("sample_type",) . showValue <$>+                 (args !? #sample_type ::+                    Maybe (EnumType '["bilinear", "nearest"])),+               ("multi_input_mode",) . showValue <$>+                 (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])),+               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "UpSampling"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        Nothing+         return listndarr++_UpSampling_upd ::+                forall args . Fullfilled "_UpSampling(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_UpSampling(ndarray)" args -> IO ()+_UpSampling_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scale",) . showValue <$> (args !? #scale :: Maybe Int),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("sample_type",) . showValue <$>+                 (args !? #sample_type ::+                    Maybe (EnumType '["bilinear", "nearest"])),+               ("multi_input_mode",) . showValue <$>+                 (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])),+               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "UpSampling"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        (Just outputs)+         return ()++type instance ParameterList "_backward_UpSampling(ndarray)" = '[]++_backward_UpSampling ::+                     forall args . Fullfilled "_backward_UpSampling(ndarray)" args =>+                       ArgsHMap "_backward_UpSampling(ndarray)" args -> IO [NDArrayHandle]+_backward_UpSampling args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_UpSampling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_UpSampling_upd ::+                         forall args . Fullfilled "_backward_UpSampling(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_UpSampling(ndarray)" args -> IO ()+_backward_UpSampling_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_UpSampling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_BatchNorm(ndarray)" =+     '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float),+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),+        '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int),+        '("cudnn_off", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),+        '("gamma", AttrOpt NDArrayHandle),+        '("beta", AttrOpt NDArrayHandle),+        '("moving_mean", AttrOpt NDArrayHandle),+        '("moving_var", AttrOpt NDArrayHandle)]++_BatchNorm ::+           forall args . Fullfilled "_BatchNorm(ndarray)" args =>+             ArgsHMap "_BatchNorm(ndarray)" args -> IO [NDArrayHandle]+_BatchNorm args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),+               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),+               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_BatchNorm_upd ::+               forall args . Fullfilled "_BatchNorm(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "_BatchNorm(ndarray)" args -> IO ()+_BatchNorm_upd outputs args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),+               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),+               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_BatchNorm(ndarray)" = '[]++_backward_BatchNorm ::+                    forall args . Fullfilled "_backward_BatchNorm(ndarray)" args =>+                      ArgsHMap "_backward_BatchNorm(ndarray)" args -> IO [NDArrayHandle]+_backward_BatchNorm args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_BatchNorm_upd ::+                        forall args . Fullfilled "_backward_BatchNorm(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_backward_BatchNorm(ndarray)" args -> IO ()+_backward_BatchNorm_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_FullyConnected(ndarray)" =+     '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool),+        '("flatten", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),+        '("weight", AttrOpt NDArrayHandle),+        '("bias", AttrOpt NDArrayHandle)]++_FullyConnected ::+                forall args . Fullfilled "_FullyConnected(ndarray)" args =>+                  ArgsHMap "_FullyConnected(ndarray)" args -> IO [NDArrayHandle]+_FullyConnected args+  = let scalarArgs+          = catMaybes+              [("num_hidden",) . showValue <$>+                 (args !? #num_hidden :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "FullyConnected"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_FullyConnected_upd ::+                    forall args . Fullfilled "_FullyConnected(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_FullyConnected(ndarray)" args -> IO ()+_FullyConnected_upd outputs args+  = let scalarArgs+          = catMaybes+              [("num_hidden",) . showValue <$>+                 (args !? #num_hidden :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "FullyConnected"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_FullyConnected(ndarray)" =+     '[]++_backward_FullyConnected ::+                         forall args .+                           Fullfilled "_backward_FullyConnected(ndarray)" args =>+                           ArgsHMap "_backward_FullyConnected(ndarray)" args ->+                             IO [NDArrayHandle]+_backward_FullyConnected args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_FullyConnected"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_FullyConnected_upd ::+                             forall args .+                               Fullfilled "_backward_FullyConnected(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_backward_FullyConnected(ndarray)" args -> IO ()+_backward_FullyConnected_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_FullyConnected"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Convolution(ndarray)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("cudnn_tune",+          AttrOpt+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+        '("cudnn_off", AttrOpt Bool),+        '("layout",+          AttrOpt+            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),+        '("data", AttrOpt NDArrayHandle),+        '("weight", AttrOpt NDArrayHandle),+        '("bias", AttrOpt NDArrayHandle)]++_Convolution ::+             forall args . Fullfilled "_Convolution(ndarray)" args =>+               ArgsHMap "_Convolution(ndarray)" args -> IO [NDArrayHandle]+_Convolution args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Convolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Convolution_upd ::+                 forall args . Fullfilled "_Convolution(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_Convolution(ndarray)" args -> IO ()+_Convolution_upd outputs args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Convolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Convolution(ndarray)" = '[]++_backward_Convolution ::+                      forall args . Fullfilled "_backward_Convolution(ndarray)" args =>+                        ArgsHMap "_backward_Convolution(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_Convolution args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Convolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Convolution_upd ::+                          forall args . Fullfilled "_backward_Convolution(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_Convolution(ndarray)" args -> IO ()+_backward_Convolution_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Convolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_LayerNorm(ndarray)" =+     '[ '("axis", AttrOpt Int), '("eps", AttrOpt Float),+        '("output_mean_var", AttrOpt Bool),+        '("data", AttrOpt NDArrayHandle),+        '("gamma", AttrOpt NDArrayHandle),+        '("beta", AttrOpt NDArrayHandle)]++_LayerNorm ::+           forall args . Fullfilled "_LayerNorm(ndarray)" args =>+             ArgsHMap "_LayerNorm(ndarray)" args -> IO [NDArrayHandle]+_LayerNorm args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LayerNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_LayerNorm_upd ::+               forall args . Fullfilled "_LayerNorm(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "_LayerNorm(ndarray)" args -> IO ()+_LayerNorm_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LayerNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_LayerNorm(ndarray)" = '[]++_backward_LayerNorm ::+                    forall args . Fullfilled "_backward_LayerNorm(ndarray)" args =>+                      ArgsHMap "_backward_LayerNorm(ndarray)" args -> IO [NDArrayHandle]+_backward_LayerNorm args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LayerNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_LayerNorm_upd ::+                        forall args . Fullfilled "_backward_LayerNorm(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_backward_LayerNorm(ndarray)" args -> IO ()+_backward_LayerNorm_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LayerNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Concat(ndarray)" =+     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),+        '("data", AttrOpt [NDArrayHandle])]++_Concat ::+        forall args . Fullfilled "_Concat(ndarray)" args =>+          ArgsHMap "_Concat(ndarray)" args -> IO [NDArrayHandle]+_Concat args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "Concat"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        Nothing+         return listndarr++_Concat_upd ::+            forall args . Fullfilled "_Concat(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "_Concat(ndarray)" args -> IO ()+_Concat_upd outputs args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "Concat"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Concat(ndarray)" = '[]++_backward_Concat ::+                 forall args . Fullfilled "_backward_Concat(ndarray)" args =>+                   ArgsHMap "_backward_Concat(ndarray)" args -> IO [NDArrayHandle]+_backward_Concat args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Concat"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Concat_upd ::+                     forall args . Fullfilled "_backward_Concat(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_backward_Concat(ndarray)" args -> IO ()+_backward_Concat_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Concat"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_rnn_param_concat(ndarray)" =+     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),+        '("data", AttrOpt [NDArrayHandle])]++_rnn_param_concat ::+                  forall args . Fullfilled "_rnn_param_concat(ndarray)" args =>+                    ArgsHMap "_rnn_param_concat(ndarray)" args -> IO [NDArrayHandle]+_rnn_param_concat args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "_rnn_param_concat"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        Nothing+         return listndarr++_rnn_param_concat_upd ::+                      forall args . Fullfilled "_rnn_param_concat(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_rnn_param_concat(ndarray)" args -> IO ()+_rnn_param_concat_upd outputs args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "_rnn_param_concat"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        (Just outputs)+         return ()++type instance ParameterList "_SoftmaxActivation(ndarray)" =+     '[ '("mode", AttrOpt (EnumType '["channel", "instance"])),+        '("data", AttrOpt NDArrayHandle)]++_SoftmaxActivation ::+                   forall args . Fullfilled "_SoftmaxActivation(ndarray)" args =>+                     ArgsHMap "_SoftmaxActivation(ndarray)" args -> IO [NDArrayHandle]+_SoftmaxActivation args+  = let scalarArgs+          = catMaybes+              [("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["channel", "instance"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SoftmaxActivation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_SoftmaxActivation_upd ::+                       forall args . Fullfilled "_SoftmaxActivation(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_SoftmaxActivation(ndarray)" args -> IO ()+_SoftmaxActivation_upd outputs args+  = let scalarArgs+          = catMaybes+              [("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["channel", "instance"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SoftmaxActivation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SoftmaxActivation(ndarray)"+     = '[]++_backward_SoftmaxActivation ::+                            forall args .+                              Fullfilled "_backward_SoftmaxActivation(ndarray)" args =>+                              ArgsHMap "_backward_SoftmaxActivation(ndarray)" args ->+                                IO [NDArrayHandle]+_backward_SoftmaxActivation args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SoftmaxActivation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SoftmaxActivation_upd ::+                                forall args .+                                  Fullfilled "_backward_SoftmaxActivation(ndarray)" args =>+                                  [NDArrayHandle] ->+                                    ArgsHMap "_backward_SoftmaxActivation(ndarray)" args -> IO ()+_backward_SoftmaxActivation_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SoftmaxActivation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_LRN(ndarray)" =+     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),+        '("knorm", AttrOpt Float), '("nsize", AttrReq Int),+        '("data", AttrOpt NDArrayHandle)]++_LRN ::+     forall args . Fullfilled "_LRN(ndarray)" args =>+       ArgsHMap "_LRN(ndarray)" args -> IO [NDArrayHandle]+_LRN args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float),+               ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LRN"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_LRN_upd ::+         forall args . Fullfilled "_LRN(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "_LRN(ndarray)" args -> IO ()+_LRN_upd outputs args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float),+               ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LRN"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_LRN(ndarray)" = '[]++_backward_LRN ::+              forall args . Fullfilled "_backward_LRN(ndarray)" args =>+                ArgsHMap "_backward_LRN(ndarray)" args -> IO [NDArrayHandle]+_backward_LRN args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LRN"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_LRN_upd ::+                  forall args . Fullfilled "_backward_LRN(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_LRN(ndarray)" args -> IO ()+_backward_LRN_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LRN"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Dropout(ndarray)" =+     '[ '("p", AttrOpt Float),+        '("mode", AttrOpt (EnumType '["always", "training"])),+        '("axes", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]++_Dropout ::+         forall args . Fullfilled "_Dropout(ndarray)" args =>+           ArgsHMap "_Dropout(ndarray)" args -> IO [NDArrayHandle]+_Dropout args+  = let scalarArgs+          = catMaybes+              [("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["always", "training"])),+               ("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Dropout"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Dropout_upd ::+             forall args . Fullfilled "_Dropout(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "_Dropout(ndarray)" args -> IO ()+_Dropout_upd outputs args+  = let scalarArgs+          = catMaybes+              [("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["always", "training"])),+               ("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Dropout"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Dropout(ndarray)" = '[]++_backward_Dropout ::+                  forall args . Fullfilled "_backward_Dropout(ndarray)" args =>+                    ArgsHMap "_backward_Dropout(ndarray)" args -> IO [NDArrayHandle]+_backward_Dropout args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Dropout"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Dropout_upd ::+                      forall args . Fullfilled "_backward_Dropout(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_Dropout(ndarray)" args -> IO ()+_backward_Dropout_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Dropout"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_dequantize(ndarray)" =+     '[ '("out_type", AttrOpt (EnumType '["float32"])),+        '("data", AttrOpt NDArrayHandle),+        '("min_range", AttrOpt NDArrayHandle),+        '("max_range", AttrOpt NDArrayHandle)]++_contrib_dequantize ::+                    forall args . Fullfilled "_contrib_dequantize(ndarray)" args =>+                      ArgsHMap "_contrib_dequantize(ndarray)" args -> IO [NDArrayHandle]+_contrib_dequantize args+  = let scalarArgs+          = catMaybes+              [("out_type",) . showValue <$>+                 (args !? #out_type :: Maybe (EnumType '["float32"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),+               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_dequantize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_dequantize_upd ::+                        forall args . Fullfilled "_contrib_dequantize(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_contrib_dequantize(ndarray)" args -> IO ()+_contrib_dequantize_upd outputs args+  = let scalarArgs+          = catMaybes+              [("out_type",) . showValue <$>+                 (args !? #out_type :: Maybe (EnumType '["float32"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),+               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_dequantize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_quantized_flatten(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle),+        '("min_data", AttrOpt NDArrayHandle),+        '("max_data", AttrOpt NDArrayHandle)]++_contrib_quantized_flatten ::+                           forall args .+                             Fullfilled "_contrib_quantized_flatten(ndarray)" args =>+                             ArgsHMap "_contrib_quantized_flatten(ndarray)" args ->+                               IO [NDArrayHandle]+_contrib_quantized_flatten args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_flatten"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_quantized_flatten_upd ::+                               forall args .+                                 Fullfilled "_contrib_quantized_flatten(ndarray)" args =>+                                 [NDArrayHandle] ->+                                   ArgsHMap "_contrib_quantized_flatten(ndarray)" args -> IO ()+_contrib_quantized_flatten_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_flatten"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_quantized_conv(ndarray)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("cudnn_tune",+          AttrOpt+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+        '("cudnn_off", AttrOpt Bool),+        '("layout",+          AttrOpt+            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),+        '("data", AttrOpt NDArrayHandle),+        '("weight", AttrOpt NDArrayHandle),+        '("bias", AttrOpt NDArrayHandle),+        '("min_data", AttrOpt NDArrayHandle),+        '("max_data", AttrOpt NDArrayHandle),+        '("min_weight", AttrOpt NDArrayHandle),+        '("max_weight", AttrOpt NDArrayHandle),+        '("min_bias", AttrOpt NDArrayHandle),+        '("max_bias", AttrOpt NDArrayHandle)]++_contrib_quantized_conv ::+                        forall args . Fullfilled "_contrib_quantized_conv(ndarray)" args =>+                          ArgsHMap "_contrib_quantized_conv(ndarray)" args ->+                            IO [NDArrayHandle]+_contrib_quantized_conv args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle),+               ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle),+               ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle),+               ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle),+               ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_conv"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_quantized_conv_upd ::+                            forall args . Fullfilled "_contrib_quantized_conv(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_contrib_quantized_conv(ndarray)" args -> IO ()+_contrib_quantized_conv_upd outputs args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle),+               ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle),+               ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle),+               ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle),+               ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_conv"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_contrib_quantized_fully_connected(ndarray)" =+     '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool),+        '("flatten", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),+        '("weight", AttrOpt NDArrayHandle),+        '("bias", AttrOpt NDArrayHandle),+        '("min_data", AttrOpt NDArrayHandle),+        '("max_data", AttrOpt NDArrayHandle),+        '("min_weight", AttrOpt NDArrayHandle),+        '("max_weight", AttrOpt NDArrayHandle),+        '("min_bias", AttrOpt NDArrayHandle),+        '("max_bias", AttrOpt NDArrayHandle)]++_contrib_quantized_fully_connected ::+                                   forall args .+                                     Fullfilled "_contrib_quantized_fully_connected(ndarray)"+                                       args =>+                                     ArgsHMap "_contrib_quantized_fully_connected(ndarray)" args ->+                                       IO [NDArrayHandle]+_contrib_quantized_fully_connected args+  = let scalarArgs+          = catMaybes+              [("num_hidden",) . showValue <$>+                 (args !? #num_hidden :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle),+               ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle),+               ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle),+               ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle),+               ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_fully_connected"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_quantized_fully_connected_upd ::+                                       forall args .+                                         Fullfilled "_contrib_quantized_fully_connected(ndarray)"+                                           args =>+                                         [NDArrayHandle] ->+                                           ArgsHMap "_contrib_quantized_fully_connected(ndarray)"+                                             args+                                             -> IO ()+_contrib_quantized_fully_connected_upd outputs args+  = let scalarArgs+          = catMaybes+              [("num_hidden",) . showValue <$>+                 (args !? #num_hidden :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle),+               ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle),+               ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle),+               ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle),+               ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_fully_connected"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_quantized_pooling(ndarray)" =+     '[ '("kernel", AttrOpt [Int]),+        '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])),+        '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool),+        '("pooling_convention", AttrOpt (EnumType '["full", "valid"])),+        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("p_value", AttrOpt (Maybe Int)),+        '("count_include_pad", AttrOpt (Maybe Bool)),+        '("data", AttrOpt NDArrayHandle),+        '("min_data", AttrOpt NDArrayHandle),+        '("max_data", AttrOpt NDArrayHandle)]++_contrib_quantized_pooling ::+                           forall args .+                             Fullfilled "_contrib_quantized_pooling(ndarray)" args =>+                             ArgsHMap "_contrib_quantized_pooling(ndarray)" args ->+                               IO [NDArrayHandle]+_contrib_quantized_pooling args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("pool_type",) . showValue <$>+                 (args !? #pool_type ::+                    Maybe (EnumType '["avg", "lp", "max", "sum"])),+               ("global_pool",) . showValue <$>+                 (args !? #global_pool :: Maybe Bool),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("pooling_convention",) . showValue <$>+                 (args !? #pooling_convention ::+                    Maybe (EnumType '["full", "valid"])),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("p_value",) . showValue <$>+                 (args !? #p_value :: Maybe (Maybe Int)),+               ("count_include_pad",) . showValue <$>+                 (args !? #count_include_pad :: Maybe (Maybe Bool))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_pooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_quantized_pooling_upd ::+                               forall args .+                                 Fullfilled "_contrib_quantized_pooling(ndarray)" args =>+                                 [NDArrayHandle] ->+                                   ArgsHMap "_contrib_quantized_pooling(ndarray)" args -> IO ()+_contrib_quantized_pooling_upd outputs args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("pool_type",) . showValue <$>+                 (args !? #pool_type ::+                    Maybe (EnumType '["avg", "lp", "max", "sum"])),+               ("global_pool",) . showValue <$>+                 (args !? #global_pool :: Maybe Bool),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("pooling_convention",) . showValue <$>+                 (args !? #pooling_convention ::+                    Maybe (EnumType '["full", "valid"])),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("p_value",) . showValue <$>+                 (args !? #p_value :: Maybe (Maybe Int)),+               ("count_include_pad",) . showValue <$>+                 (args !? #count_include_pad :: Maybe (Maybe Bool))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_pooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_requantize(ndarray)" =+     '[ '("min_calib_range", AttrOpt (Maybe Float)),+        '("max_calib_range", AttrOpt (Maybe Float)),+        '("data", AttrOpt NDArrayHandle),+        '("min_range", AttrOpt NDArrayHandle),+        '("max_range", AttrOpt NDArrayHandle)]++_contrib_requantize ::+                    forall args . Fullfilled "_contrib_requantize(ndarray)" args =>+                      ArgsHMap "_contrib_requantize(ndarray)" args -> IO [NDArrayHandle]+_contrib_requantize args+  = let scalarArgs+          = catMaybes+              [("min_calib_range",) . showValue <$>+                 (args !? #min_calib_range :: Maybe (Maybe Float)),+               ("max_calib_range",) . showValue <$>+                 (args !? #max_calib_range :: Maybe (Maybe Float))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),+               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_requantize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_requantize_upd ::+                        forall args . Fullfilled "_contrib_requantize(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_contrib_requantize(ndarray)" args -> IO ()+_contrib_requantize_upd outputs args+  = let scalarArgs+          = catMaybes+              [("min_calib_range",) . showValue <$>+                 (args !? #min_calib_range :: Maybe (Maybe Float)),+               ("max_calib_range",) . showValue <$>+                 (args !? #max_calib_range :: Maybe (Maybe Float))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),+               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_requantize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_quantize(ndarray)" =+     '[ '("out_type", AttrOpt (EnumType '["int8", "uint8"])),+        '("data", AttrOpt NDArrayHandle),+        '("min_range", AttrOpt NDArrayHandle),+        '("max_range", AttrOpt NDArrayHandle)]++_contrib_quantize ::+                  forall args . Fullfilled "_contrib_quantize(ndarray)" args =>+                    ArgsHMap "_contrib_quantize(ndarray)" args -> IO [NDArrayHandle]+_contrib_quantize args+  = let scalarArgs+          = catMaybes+              [("out_type",) . showValue <$>+                 (args !? #out_type :: Maybe (EnumType '["int8", "uint8"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),+               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_quantize_upd ::+                      forall args . Fullfilled "_contrib_quantize(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_contrib_quantize(ndarray)" args -> IO ()+_contrib_quantize_upd outputs args+  = let scalarArgs+          = catMaybes+              [("out_type",) . showValue <$>+                 (args !? #out_type :: Maybe (EnumType '["int8", "uint8"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),+               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_cvimdecode(ndarray)" =+     '[ '("flag", AttrOpt Int), '("to_rgb", AttrOpt Bool),+        '("buf", AttrOpt NDArrayHandle)]++_cvimdecode ::+            forall args . Fullfilled "_cvimdecode(ndarray)" args =>+              ArgsHMap "_cvimdecode(ndarray)" args -> IO [NDArrayHandle]+_cvimdecode args+  = let scalarArgs+          = catMaybes+              [("flag",) . showValue <$> (args !? #flag :: Maybe Int),+               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]+        tensorArgs+          = catMaybes [("buf",) <$> (args !? #buf :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_cvimdecode"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_cvimdecode_upd ::+                forall args . Fullfilled "_cvimdecode(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_cvimdecode(ndarray)" args -> IO ()+_cvimdecode_upd outputs args+  = let scalarArgs+          = catMaybes+              [("flag",) . showValue <$> (args !? #flag :: Maybe Int),+               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]+        tensorArgs+          = catMaybes [("buf",) <$> (args !? #buf :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_cvimdecode"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_cvimread(ndarray)" =+     '[ '("filename", AttrReq String), '("flag", AttrOpt Int),+        '("to_rgb", AttrOpt Bool)]++_cvimread ::+          forall args . Fullfilled "_cvimread(ndarray)" args =>+            ArgsHMap "_cvimread(ndarray)" args -> IO [NDArrayHandle]+_cvimread args+  = let scalarArgs+          = catMaybes+              [("filename",) . showValue <$> (args !? #filename :: Maybe String),+               ("flag",) . showValue <$> (args !? #flag :: Maybe Int),+               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_cvimread"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_cvimread_upd ::+              forall args . Fullfilled "_cvimread(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "_cvimread(ndarray)" args -> IO ()+_cvimread_upd outputs args+  = let scalarArgs+          = catMaybes+              [("filename",) . showValue <$> (args !? #filename :: Maybe String),+               ("flag",) . showValue <$> (args !? #flag :: Maybe Int),+               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_cvimread"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_cvimresize(ndarray)" =+     '[ '("w", AttrReq Int), '("h", AttrReq Int),+        '("interp", AttrOpt Int), '("src", AttrOpt NDArrayHandle)]++_cvimresize ::+            forall args . Fullfilled "_cvimresize(ndarray)" args =>+              ArgsHMap "_cvimresize(ndarray)" args -> IO [NDArrayHandle]+_cvimresize args+  = let scalarArgs+          = catMaybes+              [("w",) . showValue <$> (args !? #w :: Maybe Int),+               ("h",) . showValue <$> (args !? #h :: Maybe Int),+               ("interp",) . showValue <$> (args !? #interp :: Maybe Int)]+        tensorArgs+          = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_cvimresize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_cvimresize_upd ::+                forall args . Fullfilled "_cvimresize(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_cvimresize(ndarray)" args -> IO ()+_cvimresize_upd outputs args+  = let scalarArgs+          = catMaybes+              [("w",) . showValue <$> (args !? #w :: Maybe Int),+               ("h",) . showValue <$> (args !? #h :: Maybe Int),+               ("interp",) . showValue <$> (args !? #interp :: Maybe Int)]+        tensorArgs+          = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_cvimresize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_cvcopyMakeBorder(ndarray)" =+     '[ '("top", AttrReq Int), '("bot", AttrReq Int),+        '("left", AttrReq Int), '("right", AttrReq Int),+        '("type", AttrOpt Int), '("value", AttrOpt Double),+        '("values", AttrOpt [Double]), '("src", AttrOpt NDArrayHandle)]++_cvcopyMakeBorder ::+                  forall args . Fullfilled "_cvcopyMakeBorder(ndarray)" args =>+                    ArgsHMap "_cvcopyMakeBorder(ndarray)" args -> IO [NDArrayHandle]+_cvcopyMakeBorder args+  = let scalarArgs+          = catMaybes+              [("top",) . showValue <$> (args !? #top :: Maybe Int),+               ("bot",) . showValue <$> (args !? #bot :: Maybe Int),+               ("left",) . showValue <$> (args !? #left :: Maybe Int),+               ("right",) . showValue <$> (args !? #right :: Maybe Int),+               ("type",) . showValue <$> (args !? #type :: Maybe Int),+               ("value",) . showValue <$> (args !? #value :: Maybe Double),+               ("values",) . showValue <$> (args !? #values :: Maybe [Double])]+        tensorArgs+          = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_cvcopyMakeBorder"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_cvcopyMakeBorder_upd ::+                      forall args . Fullfilled "_cvcopyMakeBorder(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_cvcopyMakeBorder(ndarray)" args -> IO ()+_cvcopyMakeBorder_upd outputs args+  = let scalarArgs+          = catMaybes+              [("top",) . showValue <$> (args !? #top :: Maybe Int),+               ("bot",) . showValue <$> (args !? #bot :: Maybe Int),+               ("left",) . showValue <$> (args !? #left :: Maybe Int),+               ("right",) . showValue <$> (args !? #right :: Maybe Int),+               ("type",) . showValue <$> (args !? #type :: Maybe Int),+               ("value",) . showValue <$> (args !? #value :: Maybe Double),+               ("values",) . showValue <$> (args !? #values :: Maybe [Double])]+        tensorArgs+          = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_cvcopyMakeBorder"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_NoGradient(ndarray)" = '[]++_NoGradient ::+            forall args . Fullfilled "_NoGradient(ndarray)" args =>+              ArgsHMap "_NoGradient(ndarray)" args -> IO [NDArrayHandle]+_NoGradient args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_NoGradient"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_NoGradient_upd ::+                forall args . Fullfilled "_NoGradient(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_NoGradient(ndarray)" args -> IO ()+_NoGradient_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_NoGradient"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_CachedOp(ndarray)" = '[]++_CachedOp ::+          forall args . Fullfilled "_CachedOp(ndarray)" args =>+            ArgsHMap "_CachedOp(ndarray)" args -> IO [NDArrayHandle]+_CachedOp args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_CachedOp"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_CachedOp_upd ::+              forall args . Fullfilled "_CachedOp(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "_CachedOp(ndarray)" args -> IO ()+_CachedOp_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_CachedOp"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_CachedOp(ndarray)" = '[]++_backward_CachedOp ::+                   forall args . Fullfilled "_backward_CachedOp(ndarray)" args =>+                     ArgsHMap "_backward_CachedOp(ndarray)" args -> IO [NDArrayHandle]+_backward_CachedOp args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_CachedOp"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_CachedOp_upd ::+                       forall args . Fullfilled "_backward_CachedOp(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_backward_CachedOp(ndarray)" args -> IO ()+_backward_CachedOp_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_CachedOp"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_copyto(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_copyto ::+        forall args . Fullfilled "_copyto(ndarray)" args =>+          ArgsHMap "_copyto(ndarray)" args -> IO [NDArrayHandle]+_copyto args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_copyto"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_copyto_upd ::+            forall args . Fullfilled "_copyto(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "_copyto(ndarray)" args -> IO ()+_copyto_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_copyto"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "softmax_cross_entropy(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle),+        '("label", AttrOpt NDArrayHandle)]++softmax_cross_entropy ::+                      forall args . Fullfilled "softmax_cross_entropy(ndarray)" args =>+                        ArgsHMap "softmax_cross_entropy(ndarray)" args ->+                          IO [NDArrayHandle]+softmax_cross_entropy args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softmax_cross_entropy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++softmax_cross_entropy_upd ::+                          forall args . Fullfilled "softmax_cross_entropy(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "softmax_cross_entropy(ndarray)" args -> IO ()+softmax_cross_entropy_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softmax_cross_entropy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward_softmax_cross_entropy(ndarray)" = '[]++_backward_softmax_cross_entropy ::+                                forall args .+                                  Fullfilled "_backward_softmax_cross_entropy(ndarray)" args =>+                                  ArgsHMap "_backward_softmax_cross_entropy(ndarray)" args ->+                                    IO [NDArrayHandle]+_backward_softmax_cross_entropy args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_softmax_cross_entropy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_softmax_cross_entropy_upd ::+                                    forall args .+                                      Fullfilled "_backward_softmax_cross_entropy(ndarray)" args =>+                                      [NDArrayHandle] ->+                                        ArgsHMap "_backward_softmax_cross_entropy(ndarray)" args ->+                                          IO ()+_backward_softmax_cross_entropy_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_softmax_cross_entropy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Pad(ndarray)" =+     '[ '("mode", AttrReq (EnumType '["constant", "edge", "reflect"])),+        '("pad_width", AttrReq [Int]), '("constant_value", AttrOpt Double),+        '("data", AttrOpt NDArrayHandle)]++_Pad ::+     forall args . Fullfilled "_Pad(ndarray)" args =>+       ArgsHMap "_Pad(ndarray)" args -> IO [NDArrayHandle]+_Pad args+  = let scalarArgs+          = catMaybes+              [("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["constant", "edge", "reflect"])),+               ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]),+               ("constant_value",) . showValue <$>+                 (args !? #constant_value :: Maybe Double)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pad"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Pad_upd ::+         forall args . Fullfilled "_Pad(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "_Pad(ndarray)" args -> IO ()+_Pad_upd outputs args+  = let scalarArgs+          = catMaybes+              [("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["constant", "edge", "reflect"])),+               ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]),+               ("constant_value",) . showValue <$>+                 (args !? #constant_value :: Maybe Double)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pad"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_foreach(ndarray)" = '[]++_backward_foreach ::+                  forall args . Fullfilled "_backward_foreach(ndarray)" args =>+                    ArgsHMap "_backward_foreach(ndarray)" args -> IO [NDArrayHandle]+_backward_foreach args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_foreach"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_foreach_upd ::+                      forall args . Fullfilled "_backward_foreach(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_foreach(ndarray)" args -> IO ()+_backward_foreach_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_foreach"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_while_loop(ndarray)" = '[]++_backward_while_loop ::+                     forall args . Fullfilled "_backward_while_loop(ndarray)" args =>+                       ArgsHMap "_backward_while_loop(ndarray)" args -> IO [NDArrayHandle]+_backward_while_loop args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_while_loop"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_while_loop_upd ::+                         forall args . Fullfilled "_backward_while_loop(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_while_loop(ndarray)" args -> IO ()+_backward_while_loop_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_while_loop"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_cond(ndarray)" = '[]++_backward_cond ::+               forall args . Fullfilled "_backward_cond(ndarray)" args =>+                 ArgsHMap "_backward_cond(ndarray)" args -> IO [NDArrayHandle]+_backward_cond args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cond"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_cond_upd ::+                   forall args . Fullfilled "_backward_cond(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_cond(ndarray)" args -> IO ()+_backward_cond_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cond"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_LeakyReLU(ndarray)" =+     '[ '("act_type",+          AttrOpt (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])),+        '("slope", AttrOpt Float), '("lower_bound", AttrOpt Float),+        '("upper_bound", AttrOpt Float), '("data", AttrOpt NDArrayHandle),+        '("gamma", AttrOpt NDArrayHandle)]++_LeakyReLU ::+           forall args . Fullfilled "_LeakyReLU(ndarray)" args =>+             ArgsHMap "_LeakyReLU(ndarray)" args -> IO [NDArrayHandle]+_LeakyReLU args+  = let scalarArgs+          = catMaybes+              [("act_type",) . showValue <$>+                 (args !? #act_type ::+                    Maybe (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])),+               ("slope",) . showValue <$> (args !? #slope :: Maybe Float),+               ("lower_bound",) . showValue <$>+                 (args !? #lower_bound :: Maybe Float),+               ("upper_bound",) . showValue <$>+                 (args !? #upper_bound :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LeakyReLU"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_LeakyReLU_upd ::+               forall args . Fullfilled "_LeakyReLU(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "_LeakyReLU(ndarray)" args -> IO ()+_LeakyReLU_upd outputs args+  = let scalarArgs+          = catMaybes+              [("act_type",) . showValue <$>+                 (args !? #act_type ::+                    Maybe (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])),+               ("slope",) . showValue <$> (args !? #slope :: Maybe Float),+               ("lower_bound",) . showValue <$>+                 (args !? #lower_bound :: Maybe Float),+               ("upper_bound",) . showValue <$>+                 (args !? #upper_bound :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LeakyReLU"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_SwapAxis(ndarray)" =+     '[ '("dim1", AttrOpt Int), '("dim2", AttrOpt Int),+        '("data", AttrOpt NDArrayHandle)]++_SwapAxis ::+          forall args . Fullfilled "_SwapAxis(ndarray)" args =>+            ArgsHMap "_SwapAxis(ndarray)" args -> IO [NDArrayHandle]+_SwapAxis args+  = let scalarArgs+          = catMaybes+              [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int),+               ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SwapAxis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_SwapAxis_upd ::+              forall args . Fullfilled "_SwapAxis(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "_SwapAxis(ndarray)" args -> IO ()+_SwapAxis_upd outputs args+  = let scalarArgs+          = catMaybes+              [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int),+               ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SwapAxis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_IdentityAttachKLSparseReg(ndarray)" =+     '[ '("sparseness_target", AttrOpt Float),+        '("penalty", AttrOpt Float), '("momentum", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle)]++_IdentityAttachKLSparseReg ::+                           forall args .+                             Fullfilled "_IdentityAttachKLSparseReg(ndarray)" args =>+                             ArgsHMap "_IdentityAttachKLSparseReg(ndarray)" args ->+                               IO [NDArrayHandle]+_IdentityAttachKLSparseReg args+  = let scalarArgs+          = catMaybes+              [("sparseness_target",) . showValue <$>+                 (args !? #sparseness_target :: Maybe Float),+               ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "IdentityAttachKLSparseReg"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_IdentityAttachKLSparseReg_upd ::+                               forall args .+                                 Fullfilled "_IdentityAttachKLSparseReg(ndarray)" args =>+                                 [NDArrayHandle] ->+                                   ArgsHMap "_IdentityAttachKLSparseReg(ndarray)" args -> IO ()+_IdentityAttachKLSparseReg_upd outputs args+  = let scalarArgs+          = catMaybes+              [("sparseness_target",) . showValue <$>+                 (args !? #sparseness_target :: Maybe Float),+               ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "IdentityAttachKLSparseReg"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_SliceChannel(ndarray)" =+     '[ '("num_outputs", AttrReq Int), '("axis", AttrOpt Int),+        '("squeeze_axis", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++_SliceChannel ::+              forall args . Fullfilled "_SliceChannel(ndarray)" args =>+                ArgsHMap "_SliceChannel(ndarray)" args -> IO [NDArrayHandle]+_SliceChannel args+  = let scalarArgs+          = catMaybes+              [("num_outputs",) . showValue <$>+                 (args !? #num_outputs :: Maybe Int),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("squeeze_axis",) . showValue <$>+                 (args !? #squeeze_axis :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SliceChannel"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_SliceChannel_upd ::+                  forall args . Fullfilled "_SliceChannel(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_SliceChannel(ndarray)" args -> IO ()+_SliceChannel_upd outputs args+  = let scalarArgs+          = catMaybes+              [("num_outputs",) . showValue <$>+                 (args !? #num_outputs :: Maybe Int),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("squeeze_axis",) . showValue <$>+                 (args !? #squeeze_axis :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SliceChannel"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_BatchNorm_v1(ndarray)" =+     '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float),+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),+        '("output_mean_var", AttrOpt Bool),+        '("data", AttrOpt NDArrayHandle),+        '("gamma", AttrOpt NDArrayHandle),+        '("beta", AttrOpt NDArrayHandle)]++_BatchNorm_v1 ::+              forall args . Fullfilled "_BatchNorm_v1(ndarray)" args =>+                ArgsHMap "_BatchNorm_v1(ndarray)" args -> IO [NDArrayHandle]+_BatchNorm_v1 args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BatchNorm_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_BatchNorm_v1_upd ::+                  forall args . Fullfilled "_BatchNorm_v1(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_BatchNorm_v1(ndarray)" args -> IO ()+_BatchNorm_v1_upd outputs args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BatchNorm_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "signsgd_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle)]++signsgd_update ::+               forall args . Fullfilled "signsgd_update(ndarray)" args =>+                 ArgsHMap "signsgd_update(ndarray)" args -> IO [NDArrayHandle]+signsgd_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "signsgd_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++signsgd_update_upd ::+                   forall args . Fullfilled "signsgd_update(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "signsgd_update(ndarray)" args -> IO ()+signsgd_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "signsgd_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "signum_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("wd_lh", AttrOpt Float),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle)]++signum_update ::+              forall args . Fullfilled "signum_update(ndarray)" args =>+                ArgsHMap "signum_update(ndarray)" args -> IO [NDArrayHandle]+signum_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("wd_lh",) . showValue <$> (args !? #wd_lh :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "signum_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++signum_update_upd ::+                  forall args . Fullfilled "signum_update(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "signum_update(ndarray)" args -> IO ()+signum_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("wd_lh",) . showValue <$> (args !? #wd_lh :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "signum_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "sgd_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle)]++sgd_update ::+           forall args . Fullfilled "sgd_update(ndarray)" args =>+             ArgsHMap "sgd_update(ndarray)" args -> IO [NDArrayHandle]+sgd_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sgd_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++sgd_update_upd ::+               forall args . Fullfilled "sgd_update(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "sgd_update(ndarray)" args -> IO ()+sgd_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sgd_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "sgd_mom_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle)]++sgd_mom_update ::+               forall args . Fullfilled "sgd_mom_update(ndarray)" args =>+                 ArgsHMap "sgd_mom_update(ndarray)" args -> IO [NDArrayHandle]+sgd_mom_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sgd_mom_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++sgd_mom_update_upd ::+                   forall args . Fullfilled "sgd_mom_update(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "sgd_mom_update(ndarray)" args -> IO ()+sgd_mom_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sgd_mom_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "mp_sgd_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle),+        '("weight32", AttrOpt NDArrayHandle)]++mp_sgd_update ::+              forall args . Fullfilled "mp_sgd_update(ndarray)" args =>+                ArgsHMap "mp_sgd_update(ndarray)" args -> IO [NDArrayHandle]+mp_sgd_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mp_sgd_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++mp_sgd_update_upd ::+                  forall args . Fullfilled "mp_sgd_update(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "mp_sgd_update(ndarray)" args -> IO ()+mp_sgd_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mp_sgd_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "mp_sgd_mom_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle),+        '("weight32", AttrOpt NDArrayHandle)]++mp_sgd_mom_update ::+                  forall args . Fullfilled "mp_sgd_mom_update(ndarray)" args =>+                    ArgsHMap "mp_sgd_mom_update(ndarray)" args -> IO [NDArrayHandle]+mp_sgd_mom_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle),+               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mp_sgd_mom_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++mp_sgd_mom_update_upd ::+                      forall args . Fullfilled "mp_sgd_mom_update(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "mp_sgd_mom_update(ndarray)" args -> IO ()+mp_sgd_mom_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle),+               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mp_sgd_mom_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "ftml_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),+        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Double),+        '("t", AttrReq Int), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float), '("clip_grad", AttrOpt Float),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle), '("d", AttrOpt NDArrayHandle),+        '("v", AttrOpt NDArrayHandle), '("z", AttrOpt NDArrayHandle)]++ftml_update ::+            forall args . Fullfilled "ftml_update(ndarray)" args =>+              ArgsHMap "ftml_update(ndarray)" args -> IO [NDArrayHandle]+ftml_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Double),+               ("t",) . showValue <$> (args !? #t :: Maybe Int),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_grad",) . showValue <$> (args !? #clip_grad :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("d",) <$> (args !? #d :: Maybe NDArrayHandle),+               ("v",) <$> (args !? #v :: Maybe NDArrayHandle),+               ("z",) <$> (args !? #z :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ftml_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++ftml_update_upd ::+                forall args . Fullfilled "ftml_update(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "ftml_update(ndarray)" args -> IO ()+ftml_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Double),+               ("t",) . showValue <$> (args !? #t :: Maybe Int),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_grad",) . showValue <$> (args !? #clip_grad :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("d",) <$> (args !? #d :: Maybe NDArrayHandle),+               ("v",) <$> (args !? #v :: Maybe NDArrayHandle),+               ("z",) <$> (args !? #z :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ftml_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "adam_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),+        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle), '("mean", AttrOpt NDArrayHandle),+        '("var", AttrOpt NDArrayHandle)]++adam_update ::+            forall args . Fullfilled "adam_update(ndarray)" args =>+              ArgsHMap "adam_update(ndarray)" args -> IO [NDArrayHandle]+adam_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle),+               ("var",) <$> (args !? #var :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "adam_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++adam_update_upd ::+                forall args . Fullfilled "adam_update(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "adam_update(ndarray)" args -> IO ()+adam_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle),+               ("var",) <$> (args !? #var :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "adam_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "rmsprop_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),+        '("epsilon", AttrOpt Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("clip_weights", AttrOpt Float),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle), '("n", AttrOpt NDArrayHandle)]++rmsprop_update ::+               forall args . Fullfilled "rmsprop_update(ndarray)" args =>+                 ArgsHMap "rmsprop_update(ndarray)" args -> IO [NDArrayHandle]+rmsprop_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("clip_weights",) . showValue <$>+                 (args !? #clip_weights :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("n",) <$> (args !? #n :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rmsprop_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++rmsprop_update_upd ::+                   forall args . Fullfilled "rmsprop_update(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "rmsprop_update(ndarray)" args -> IO ()+rmsprop_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("clip_weights",) . showValue <$>+                 (args !? #clip_weights :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("n",) <$> (args !? #n :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rmsprop_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "rmspropalex_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),+        '("gamma2", AttrOpt Float), '("epsilon", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("clip_weights", AttrOpt Float),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle), '("n", AttrOpt NDArrayHandle),+        '("g", AttrOpt NDArrayHandle), '("delta", AttrOpt NDArrayHandle)]++rmspropalex_update ::+                   forall args . Fullfilled "rmspropalex_update(ndarray)" args =>+                     ArgsHMap "rmspropalex_update(ndarray)" args -> IO [NDArrayHandle]+rmspropalex_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),+               ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("clip_weights",) . showValue <$>+                 (args !? #clip_weights :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("n",) <$> (args !? #n :: Maybe NDArrayHandle),+               ("g",) <$> (args !? #g :: Maybe NDArrayHandle),+               ("delta",) <$> (args !? #delta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rmspropalex_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++rmspropalex_update_upd ::+                       forall args . Fullfilled "rmspropalex_update(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "rmspropalex_update(ndarray)" args -> IO ()+rmspropalex_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),+               ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("clip_weights",) . showValue <$>+                 (args !? #clip_weights :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("n",) <$> (args !? #n :: Maybe NDArrayHandle),+               ("g",) <$> (args !? #g :: Maybe NDArrayHandle),+               ("delta",) <$> (args !? #delta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rmspropalex_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "ftrl_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("lamda1", AttrOpt Float),+        '("beta", AttrOpt Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle), '("z", AttrOpt NDArrayHandle),+        '("n", AttrOpt NDArrayHandle)]++ftrl_update ::+            forall args . Fullfilled "ftrl_update(ndarray)" args =>+              ArgsHMap "ftrl_update(ndarray)" args -> IO [NDArrayHandle]+ftrl_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("z",) <$> (args !? #z :: Maybe NDArrayHandle),+               ("n",) <$> (args !? #n :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ftrl_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++ftrl_update_upd ::+                forall args . Fullfilled "ftrl_update(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "ftrl_update(ndarray)" args -> IO ()+ftrl_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("z",) <$> (args !? #z :: Maybe NDArrayHandle),+               ("n",) <$> (args !? #n :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ftrl_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_sparse_adagrad_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("epsilon", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle),+        '("history", AttrOpt NDArrayHandle)]++_sparse_adagrad_update ::+                       forall args . Fullfilled "_sparse_adagrad_update(ndarray)" args =>+                         ArgsHMap "_sparse_adagrad_update(ndarray)" args ->+                           IO [NDArrayHandle]+_sparse_adagrad_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("history",) <$> (args !? #history :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sparse_adagrad_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sparse_adagrad_update_upd ::+                           forall args . Fullfilled "_sparse_adagrad_update(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_sparse_adagrad_update(ndarray)" args -> IO ()+_sparse_adagrad_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("history",) <$> (args !? #history :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sparse_adagrad_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_LinearRegressionOutput(ndarray)" =+     '[ '("grad_scale", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle),+        '("label", AttrOpt NDArrayHandle)]++_LinearRegressionOutput ::+                        forall args . Fullfilled "_LinearRegressionOutput(ndarray)" args =>+                          ArgsHMap "_LinearRegressionOutput(ndarray)" args ->+                            IO [NDArrayHandle]+_LinearRegressionOutput args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LinearRegressionOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_LinearRegressionOutput_upd ::+                            forall args . Fullfilled "_LinearRegressionOutput(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_LinearRegressionOutput(ndarray)" args -> IO ()+_LinearRegressionOutput_upd outputs args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LinearRegressionOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linear_reg_out(ndarray)" =+     '[]++_backward_linear_reg_out ::+                         forall args .+                           Fullfilled "_backward_linear_reg_out(ndarray)" args =>+                           ArgsHMap "_backward_linear_reg_out(ndarray)" args ->+                             IO [NDArrayHandle]+_backward_linear_reg_out args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linear_reg_out"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linear_reg_out_upd ::+                             forall args .+                               Fullfilled "_backward_linear_reg_out(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_backward_linear_reg_out(ndarray)" args -> IO ()+_backward_linear_reg_out_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linear_reg_out"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_MAERegressionOutput(ndarray)" =+     '[ '("grad_scale", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle),+        '("label", AttrOpt NDArrayHandle)]++_MAERegressionOutput ::+                     forall args . Fullfilled "_MAERegressionOutput(ndarray)" args =>+                       ArgsHMap "_MAERegressionOutput(ndarray)" args -> IO [NDArrayHandle]+_MAERegressionOutput args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "MAERegressionOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_MAERegressionOutput_upd ::+                         forall args . Fullfilled "_MAERegressionOutput(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_MAERegressionOutput(ndarray)" args -> IO ()+_MAERegressionOutput_upd outputs args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "MAERegressionOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_mae_reg_out(ndarray)" = '[]++_backward_mae_reg_out ::+                      forall args . Fullfilled "_backward_mae_reg_out(ndarray)" args =>+                        ArgsHMap "_backward_mae_reg_out(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_mae_reg_out args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mae_reg_out"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_mae_reg_out_upd ::+                          forall args . Fullfilled "_backward_mae_reg_out(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_mae_reg_out(ndarray)" args -> IO ()+_backward_mae_reg_out_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mae_reg_out"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_LogisticRegressionOutput(ndarray)" =+     '[ '("grad_scale", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle),+        '("label", AttrOpt NDArrayHandle)]++_LogisticRegressionOutput ::+                          forall args .+                            Fullfilled "_LogisticRegressionOutput(ndarray)" args =>+                            ArgsHMap "_LogisticRegressionOutput(ndarray)" args ->+                              IO [NDArrayHandle]+_LogisticRegressionOutput args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LogisticRegressionOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_LogisticRegressionOutput_upd ::+                              forall args .+                                Fullfilled "_LogisticRegressionOutput(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_LogisticRegressionOutput(ndarray)" args -> IO ()+_LogisticRegressionOutput_upd outputs args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LogisticRegressionOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_logistic_reg_out(ndarray)" =+     '[]++_backward_logistic_reg_out ::+                           forall args .+                             Fullfilled "_backward_logistic_reg_out(ndarray)" args =>+                             ArgsHMap "_backward_logistic_reg_out(ndarray)" args ->+                               IO [NDArrayHandle]+_backward_logistic_reg_out args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_logistic_reg_out"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_logistic_reg_out_upd ::+                               forall args .+                                 Fullfilled "_backward_logistic_reg_out(ndarray)" args =>+                                 [NDArrayHandle] ->+                                   ArgsHMap "_backward_logistic_reg_out(ndarray)" args -> IO ()+_backward_logistic_reg_out_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_logistic_reg_out"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_CustomFunction(ndarray)" = '[]++_CustomFunction ::+                forall args . Fullfilled "_CustomFunction(ndarray)" args =>+                  ArgsHMap "_CustomFunction(ndarray)" args -> IO [NDArrayHandle]+_CustomFunction args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_CustomFunction"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_CustomFunction_upd ::+                    forall args . Fullfilled "_CustomFunction(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_CustomFunction(ndarray)" args -> IO ()+_CustomFunction_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_CustomFunction"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_CustomFunction(ndarray)" =+     '[]++_backward_CustomFunction ::+                         forall args .+                           Fullfilled "_backward_CustomFunction(ndarray)" args =>+                           ArgsHMap "_backward_CustomFunction(ndarray)" args ->+                             IO [NDArrayHandle]+_backward_CustomFunction args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_CustomFunction"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_CustomFunction_upd ::+                             forall args .+                               Fullfilled "_backward_CustomFunction(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_backward_CustomFunction(ndarray)" args -> IO ()+_backward_CustomFunction_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_CustomFunction"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward__Native(ndarray)" = '[]++_backward__Native ::+                  forall args . Fullfilled "_backward__Native(ndarray)" args =>+                    ArgsHMap "_backward__Native(ndarray)" args -> IO [NDArrayHandle]+_backward__Native args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__Native"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__Native_upd ::+                      forall args . Fullfilled "_backward__Native(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward__Native(ndarray)" args -> IO ()+_backward__Native_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__Native"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward__NDArray(ndarray)" = '[]++_backward__NDArray ::+                   forall args . Fullfilled "_backward__NDArray(ndarray)" args =>+                     ArgsHMap "_backward__NDArray(ndarray)" args -> IO [NDArrayHandle]+_backward__NDArray args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__NDArray"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__NDArray_upd ::+                       forall args . Fullfilled "_backward__NDArray(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_backward__NDArray(ndarray)" args -> IO ()+_backward__NDArray_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__NDArray"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_MultiBoxTarget(ndarray)" =+     '[ '("overlap_threshold", AttrOpt Float),+        '("ignore_label", AttrOpt Float),+        '("negative_mining_ratio", AttrOpt Float),+        '("negative_mining_thresh", AttrOpt Float),+        '("minimum_negative_samples", AttrOpt Int),+        '("variances", AttrOpt [Float]),+        '("anchor", AttrOpt NDArrayHandle),+        '("label", AttrOpt NDArrayHandle),+        '("cls_pred", AttrOpt NDArrayHandle)]++_contrib_MultiBoxTarget ::+                        forall args . Fullfilled "_contrib_MultiBoxTarget(ndarray)" args =>+                          ArgsHMap "_contrib_MultiBoxTarget(ndarray)" args ->+                            IO [NDArrayHandle]+_contrib_MultiBoxTarget args+  = let scalarArgs+          = catMaybes+              [("overlap_threshold",) . showValue <$>+                 (args !? #overlap_threshold :: Maybe Float),+               ("ignore_label",) . showValue <$>+                 (args !? #ignore_label :: Maybe Float),+               ("negative_mining_ratio",) . showValue <$>+                 (args !? #negative_mining_ratio :: Maybe Float),+               ("negative_mining_thresh",) . showValue <$>+                 (args !? #negative_mining_thresh :: Maybe Float),+               ("minimum_negative_samples",) . showValue <$>+                 (args !? #minimum_negative_samples :: Maybe Int),+               ("variances",) . showValue <$>+                 (args !? #variances :: Maybe [Float])]+        tensorArgs+          = catMaybes+              [("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle),+               ("cls_pred",) <$> (args !? #cls_pred :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxTarget"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_MultiBoxTarget_upd ::+                            forall args . Fullfilled "_contrib_MultiBoxTarget(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_contrib_MultiBoxTarget(ndarray)" args -> IO ()+_contrib_MultiBoxTarget_upd outputs args+  = let scalarArgs+          = catMaybes+              [("overlap_threshold",) . showValue <$>+                 (args !? #overlap_threshold :: Maybe Float),+               ("ignore_label",) . showValue <$>+                 (args !? #ignore_label :: Maybe Float),+               ("negative_mining_ratio",) . showValue <$>+                 (args !? #negative_mining_ratio :: Maybe Float),+               ("negative_mining_thresh",) . showValue <$>+                 (args !? #negative_mining_thresh :: Maybe Float),+               ("minimum_negative_samples",) . showValue <$>+                 (args !? #minimum_negative_samples :: Maybe Int),+               ("variances",) . showValue <$>+                 (args !? #variances :: Maybe [Float])]+        tensorArgs+          = catMaybes+              [("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle),+               ("cls_pred",) <$> (args !? #cls_pred :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxTarget"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward__contrib_MultiBoxTarget(ndarray)" = '[]++_backward__contrib_MultiBoxTarget ::+                                  forall args .+                                    Fullfilled "_backward__contrib_MultiBoxTarget(ndarray)" args =>+                                    ArgsHMap "_backward__contrib_MultiBoxTarget(ndarray)" args ->+                                      IO [NDArrayHandle]+_backward__contrib_MultiBoxTarget args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_MultiBoxTarget_upd ::+                                      forall args .+                                        Fullfilled "_backward__contrib_MultiBoxTarget(ndarray)"+                                          args =>+                                        [NDArrayHandle] ->+                                          ArgsHMap "_backward__contrib_MultiBoxTarget(ndarray)" args+                                            -> IO ()+_backward__contrib_MultiBoxTarget_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_Proposal(ndarray)" =+     '[ '("rpn_pre_nms_top_n", AttrOpt Int),+        '("rpn_post_nms_top_n", AttrOpt Int),+        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),+        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),+        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),+        '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt NDArrayHandle),+        '("bbox_pred", AttrOpt NDArrayHandle),+        '("im_info", AttrOpt NDArrayHandle)]++_contrib_Proposal ::+                  forall args . Fullfilled "_contrib_Proposal(ndarray)" args =>+                    ArgsHMap "_contrib_Proposal(ndarray)" args -> IO [NDArrayHandle]+_contrib_Proposal args+  = let scalarArgs+          = catMaybes+              [("rpn_pre_nms_top_n",) . showValue <$>+                 (args !? #rpn_pre_nms_top_n :: Maybe Int),+               ("rpn_post_nms_top_n",) . showValue <$>+                 (args !? #rpn_post_nms_top_n :: Maybe Int),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("rpn_min_size",) . showValue <$>+                 (args !? #rpn_min_size :: Maybe Int),+               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("feature_stride",) . showValue <$>+                 (args !? #feature_stride :: Maybe Int),+               ("output_score",) . showValue <$>+                 (args !? #output_score :: Maybe Bool),+               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),+               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle),+               ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_Proposal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_Proposal_upd ::+                      forall args . Fullfilled "_contrib_Proposal(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_contrib_Proposal(ndarray)" args -> IO ()+_contrib_Proposal_upd outputs args+  = let scalarArgs+          = catMaybes+              [("rpn_pre_nms_top_n",) . showValue <$>+                 (args !? #rpn_pre_nms_top_n :: Maybe Int),+               ("rpn_post_nms_top_n",) . showValue <$>+                 (args !? #rpn_post_nms_top_n :: Maybe Int),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("rpn_min_size",) . showValue <$>+                 (args !? #rpn_min_size :: Maybe Int),+               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("feature_stride",) . showValue <$>+                 (args !? #feature_stride :: Maybe Int),+               ("output_score",) . showValue <$>+                 (args !? #output_score :: Maybe Bool),+               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),+               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle),+               ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_Proposal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward__contrib_Proposal(ndarray)"+     = '[]++_backward__contrib_Proposal ::+                            forall args .+                              Fullfilled "_backward__contrib_Proposal(ndarray)" args =>+                              ArgsHMap "_backward__contrib_Proposal(ndarray)" args ->+                                IO [NDArrayHandle]+_backward__contrib_Proposal args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_Proposal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_Proposal_upd ::+                                forall args .+                                  Fullfilled "_backward__contrib_Proposal(ndarray)" args =>+                                  [NDArrayHandle] ->+                                    ArgsHMap "_backward__contrib_Proposal(ndarray)" args -> IO ()+_backward__contrib_Proposal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_Proposal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_count_sketch(ndarray)" =+     '[ '("out_dim", AttrReq Int),+        '("processing_batch_size", AttrOpt Int),+        '("data", AttrOpt NDArrayHandle), '("h", AttrOpt NDArrayHandle),+        '("s", AttrOpt NDArrayHandle)]++_contrib_count_sketch ::+                      forall args . Fullfilled "_contrib_count_sketch(ndarray)" args =>+                        ArgsHMap "_contrib_count_sketch(ndarray)" args ->+                          IO [NDArrayHandle]+_contrib_count_sketch args+  = let scalarArgs+          = catMaybes+              [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int),+               ("processing_batch_size",) . showValue <$>+                 (args !? #processing_batch_size :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("h",) <$> (args !? #h :: Maybe NDArrayHandle),+               ("s",) <$> (args !? #s :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_count_sketch"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_count_sketch_upd ::+                          forall args . Fullfilled "_contrib_count_sketch(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_contrib_count_sketch(ndarray)" args -> IO ()+_contrib_count_sketch_upd outputs args+  = let scalarArgs+          = catMaybes+              [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int),+               ("processing_batch_size",) . showValue <$>+                 (args !? #processing_batch_size :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("h",) <$> (args !? #h :: Maybe NDArrayHandle),+               ("s",) <$> (args !? #s :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_count_sketch"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward__contrib_count_sketch(ndarray)" = '[]++_backward__contrib_count_sketch ::+                                forall args .+                                  Fullfilled "_backward__contrib_count_sketch(ndarray)" args =>+                                  ArgsHMap "_backward__contrib_count_sketch(ndarray)" args ->+                                    IO [NDArrayHandle]+_backward__contrib_count_sketch args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_count_sketch"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_count_sketch_upd ::+                                    forall args .+                                      Fullfilled "_backward__contrib_count_sketch(ndarray)" args =>+                                      [NDArrayHandle] ->+                                        ArgsHMap "_backward__contrib_count_sketch(ndarray)" args ->+                                          IO ()+_backward__contrib_count_sketch_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_count_sketch"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_MultiBoxDetection(ndarray)" =+     '[ '("clip", AttrOpt Bool), '("threshold", AttrOpt Float),+        '("background_id", AttrOpt Int), '("nms_threshold", AttrOpt Float),+        '("force_suppress", AttrOpt Bool), '("variances", AttrOpt [Float]),+        '("nms_topk", AttrOpt Int), '("cls_prob", AttrOpt NDArrayHandle),+        '("loc_pred", AttrOpt NDArrayHandle),+        '("anchor", AttrOpt NDArrayHandle)]++_contrib_MultiBoxDetection ::+                           forall args .+                             Fullfilled "_contrib_MultiBoxDetection(ndarray)" args =>+                             ArgsHMap "_contrib_MultiBoxDetection(ndarray)" args ->+                               IO [NDArrayHandle]+_contrib_MultiBoxDetection args+  = let scalarArgs+          = catMaybes+              [("clip",) . showValue <$> (args !? #clip :: Maybe Bool),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("background_id",) . showValue <$>+                 (args !? #background_id :: Maybe Int),+               ("nms_threshold",) . showValue <$>+                 (args !? #nms_threshold :: Maybe Float),+               ("force_suppress",) . showValue <$>+                 (args !? #force_suppress :: Maybe Bool),+               ("variances",) . showValue <$>+                 (args !? #variances :: Maybe [Float]),+               ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),+               ("loc_pred",) <$> (args !? #loc_pred :: Maybe NDArrayHandle),+               ("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxDetection"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_MultiBoxDetection_upd ::+                               forall args .+                                 Fullfilled "_contrib_MultiBoxDetection(ndarray)" args =>+                                 [NDArrayHandle] ->+                                   ArgsHMap "_contrib_MultiBoxDetection(ndarray)" args -> IO ()+_contrib_MultiBoxDetection_upd outputs args+  = let scalarArgs+          = catMaybes+              [("clip",) . showValue <$> (args !? #clip :: Maybe Bool),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("background_id",) . showValue <$>+                 (args !? #background_id :: Maybe Int),+               ("nms_threshold",) . showValue <$>+                 (args !? #nms_threshold :: Maybe Float),+               ("force_suppress",) . showValue <$>+                 (args !? #force_suppress :: Maybe Bool),+               ("variances",) . showValue <$>+                 (args !? #variances :: Maybe [Float]),+               ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),+               ("loc_pred",) <$> (args !? #loc_pred :: Maybe NDArrayHandle),+               ("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxDetection"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward__contrib_MultiBoxDetection(ndarray)" = '[]++_backward__contrib_MultiBoxDetection ::+                                     forall args .+                                       Fullfilled "_backward__contrib_MultiBoxDetection(ndarray)"+                                         args =>+                                       ArgsHMap "_backward__contrib_MultiBoxDetection(ndarray)" args+                                         -> IO [NDArrayHandle]+_backward__contrib_MultiBoxDetection args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_MultiBoxDetection_upd ::+                                         forall args .+                                           Fullfilled+                                             "_backward__contrib_MultiBoxDetection(ndarray)" args =>+                                           [NDArrayHandle] ->+                                             ArgsHMap+                                               "_backward__contrib_MultiBoxDetection(ndarray)"+                                               args+                                               -> IO ()+_backward__contrib_MultiBoxDetection_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward__contrib_DeformablePSROIPooling(ndarray)"+     = '[]++_backward__contrib_DeformablePSROIPooling ::+                                          forall args .+                                            Fullfilled+                                              "_backward__contrib_DeformablePSROIPooling(ndarray)"+                                              args =>+                                            ArgsHMap+                                              "_backward__contrib_DeformablePSROIPooling(ndarray)"+                                              args+                                              -> IO [NDArrayHandle]+_backward__contrib_DeformablePSROIPooling args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_DeformablePSROIPooling_upd ::+                                              forall args .+                                                Fullfilled+                                                  "_backward__contrib_DeformablePSROIPooling(ndarray)"+                                                  args =>+                                                [NDArrayHandle] ->+                                                  ArgsHMap+                                                    "_backward__contrib_DeformablePSROIPooling(ndarray)"+                                                    args+                                                    -> IO ()+_backward__contrib_DeformablePSROIPooling_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward__contrib_CTCLoss(ndarray)" =+     '[]++_backward__contrib_CTCLoss ::+                           forall args .+                             Fullfilled "_backward__contrib_CTCLoss(ndarray)" args =>+                             ArgsHMap "_backward__contrib_CTCLoss(ndarray)" args ->+                               IO [NDArrayHandle]+_backward__contrib_CTCLoss args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_CTCLoss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_CTCLoss_upd ::+                               forall args .+                                 Fullfilled "_backward__contrib_CTCLoss(ndarray)" args =>+                                 [NDArrayHandle] ->+                                   ArgsHMap "_backward__contrib_CTCLoss(ndarray)" args -> IO ()+_backward__contrib_CTCLoss_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_CTCLoss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_MultiProposal(ndarray)" =+     '[ '("rpn_pre_nms_top_n", AttrOpt Int),+        '("rpn_post_nms_top_n", AttrOpt Int),+        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),+        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),+        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),+        '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt NDArrayHandle),+        '("bbox_pred", AttrOpt NDArrayHandle),+        '("im_info", AttrOpt NDArrayHandle)]++_contrib_MultiProposal ::+                       forall args . Fullfilled "_contrib_MultiProposal(ndarray)" args =>+                         ArgsHMap "_contrib_MultiProposal(ndarray)" args ->+                           IO [NDArrayHandle]+_contrib_MultiProposal args+  = let scalarArgs+          = catMaybes+              [("rpn_pre_nms_top_n",) . showValue <$>+                 (args !? #rpn_pre_nms_top_n :: Maybe Int),+               ("rpn_post_nms_top_n",) . showValue <$>+                 (args !? #rpn_post_nms_top_n :: Maybe Int),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("rpn_min_size",) . showValue <$>+                 (args !? #rpn_min_size :: Maybe Int),+               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("feature_stride",) . showValue <$>+                 (args !? #feature_stride :: Maybe Int),+               ("output_score",) . showValue <$>+                 (args !? #output_score :: Maybe Bool),+               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),+               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle),+               ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiProposal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_MultiProposal_upd ::+                           forall args . Fullfilled "_contrib_MultiProposal(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_contrib_MultiProposal(ndarray)" args -> IO ()+_contrib_MultiProposal_upd outputs args+  = let scalarArgs+          = catMaybes+              [("rpn_pre_nms_top_n",) . showValue <$>+                 (args !? #rpn_pre_nms_top_n :: Maybe Int),+               ("rpn_post_nms_top_n",) . showValue <$>+                 (args !? #rpn_post_nms_top_n :: Maybe Int),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("rpn_min_size",) . showValue <$>+                 (args !? #rpn_min_size :: Maybe Int),+               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("feature_stride",) . showValue <$>+                 (args !? #feature_stride :: Maybe Int),+               ("output_score",) . showValue <$>+                 (args !? #output_score :: Maybe Bool),+               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),+               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle),+               ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiProposal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward__contrib_MultiProposal(ndarray)" = '[]++_backward__contrib_MultiProposal ::+                                 forall args .+                                   Fullfilled "_backward__contrib_MultiProposal(ndarray)" args =>+                                   ArgsHMap "_backward__contrib_MultiProposal(ndarray)" args ->+                                     IO [NDArrayHandle]+_backward__contrib_MultiProposal args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiProposal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_MultiProposal_upd ::+                                     forall args .+                                       Fullfilled "_backward__contrib_MultiProposal(ndarray)"+                                         args =>+                                       [NDArrayHandle] ->+                                         ArgsHMap "_backward__contrib_MultiProposal(ndarray)" args+                                           -> IO ()+_backward__contrib_MultiProposal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiProposal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_MultiBoxPrior(ndarray)" =+     '[ '("sizes", AttrOpt [Float]), '("ratios", AttrOpt [Float]),+        '("clip", AttrOpt Bool), '("steps", AttrOpt [Float]),+        '("offsets", AttrOpt [Float]), '("data", AttrOpt NDArrayHandle)]++_contrib_MultiBoxPrior ::+                       forall args . Fullfilled "_contrib_MultiBoxPrior(ndarray)" args =>+                         ArgsHMap "_contrib_MultiBoxPrior(ndarray)" args ->+                           IO [NDArrayHandle]+_contrib_MultiBoxPrior args+  = let scalarArgs+          = catMaybes+              [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("clip",) . showValue <$> (args !? #clip :: Maybe Bool),+               ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]),+               ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxPrior"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_MultiBoxPrior_upd ::+                           forall args . Fullfilled "_contrib_MultiBoxPrior(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_contrib_MultiBoxPrior(ndarray)" args -> IO ()+_contrib_MultiBoxPrior_upd outputs args+  = let scalarArgs+          = catMaybes+              [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("clip",) . showValue <$> (args !? #clip :: Maybe Bool),+               ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]),+               ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxPrior"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward__contrib_MultiBoxPrior(ndarray)" = '[]++_backward__contrib_MultiBoxPrior ::+                                 forall args .+                                   Fullfilled "_backward__contrib_MultiBoxPrior(ndarray)" args =>+                                   ArgsHMap "_backward__contrib_MultiBoxPrior(ndarray)" args ->+                                     IO [NDArrayHandle]+_backward__contrib_MultiBoxPrior args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_MultiBoxPrior_upd ::+                                     forall args .+                                       Fullfilled "_backward__contrib_MultiBoxPrior(ndarray)"+                                         args =>+                                       [NDArrayHandle] ->+                                         ArgsHMap "_backward__contrib_MultiBoxPrior(ndarray)" args+                                           -> IO ()+_backward__contrib_MultiBoxPrior_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_fft(ndarray)" =+     '[ '("compute_size", AttrOpt Int),+        '("data", AttrOpt NDArrayHandle)]++_contrib_fft ::+             forall args . Fullfilled "_contrib_fft(ndarray)" args =>+               ArgsHMap "_contrib_fft(ndarray)" args -> IO [NDArrayHandle]+_contrib_fft args+  = let scalarArgs+          = catMaybes+              [("compute_size",) . showValue <$>+                 (args !? #compute_size :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_fft"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_fft_upd ::+                 forall args . Fullfilled "_contrib_fft(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_contrib_fft(ndarray)" args -> IO ()+_contrib_fft_upd outputs args+  = let scalarArgs+          = catMaybes+              [("compute_size",) . showValue <$>+                 (args !? #compute_size :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_fft"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward__contrib_fft(ndarray)" = '[]++_backward__contrib_fft ::+                       forall args . Fullfilled "_backward__contrib_fft(ndarray)" args =>+                         ArgsHMap "_backward__contrib_fft(ndarray)" args ->+                           IO [NDArrayHandle]+_backward__contrib_fft args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_fft"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_fft_upd ::+                           forall args . Fullfilled "_backward__contrib_fft(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward__contrib_fft(ndarray)" args -> IO ()+_backward__contrib_fft_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_fft"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward__contrib_PSROIPooling(ndarray)" = '[]++_backward__contrib_PSROIPooling ::+                                forall args .+                                  Fullfilled "_backward__contrib_PSROIPooling(ndarray)" args =>+                                  ArgsHMap "_backward__contrib_PSROIPooling(ndarray)" args ->+                                    IO [NDArrayHandle]+_backward__contrib_PSROIPooling args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_PSROIPooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_PSROIPooling_upd ::+                                    forall args .+                                      Fullfilled "_backward__contrib_PSROIPooling(ndarray)" args =>+                                      [NDArrayHandle] ->+                                        ArgsHMap "_backward__contrib_PSROIPooling(ndarray)" args ->+                                          IO ()+_backward__contrib_PSROIPooling_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_PSROIPooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_contrib_DeformableConvolution(ndarray)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("num_deformable_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("layout", AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NCW"]))),+        '("data", AttrOpt NDArrayHandle),+        '("offset", AttrOpt NDArrayHandle),+        '("weight", AttrOpt NDArrayHandle),+        '("bias", AttrOpt NDArrayHandle)]++_contrib_DeformableConvolution ::+                               forall args .+                                 Fullfilled "_contrib_DeformableConvolution(ndarray)" args =>+                                 ArgsHMap "_contrib_DeformableConvolution(ndarray)" args ->+                                   IO [NDArrayHandle]+_contrib_DeformableConvolution args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("num_deformable_group",) . showValue <$>+                 (args !? #num_deformable_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("offset",) <$> (args !? #offset :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_DeformableConvolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_DeformableConvolution_upd ::+                                   forall args .+                                     Fullfilled "_contrib_DeformableConvolution(ndarray)" args =>+                                     [NDArrayHandle] ->+                                       ArgsHMap "_contrib_DeformableConvolution(ndarray)" args ->+                                         IO ()+_contrib_DeformableConvolution_upd outputs args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("num_deformable_group",) . showValue <$>+                 (args !? #num_deformable_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("offset",) <$> (args !? #offset :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_DeformableConvolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward__contrib_DeformableConvolution(ndarray)" =+     '[]++_backward__contrib_DeformableConvolution ::+                                         forall args .+                                           Fullfilled+                                             "_backward__contrib_DeformableConvolution(ndarray)"+                                             args =>+                                           ArgsHMap+                                             "_backward__contrib_DeformableConvolution(ndarray)"+                                             args+                                             -> IO [NDArrayHandle]+_backward__contrib_DeformableConvolution args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_DeformableConvolution_upd ::+                                             forall args .+                                               Fullfilled+                                                 "_backward__contrib_DeformableConvolution(ndarray)"+                                                 args =>+                                               [NDArrayHandle] ->+                                                 ArgsHMap+                                                   "_backward__contrib_DeformableConvolution(ndarray)"+                                                   args+                                                   -> IO ()+_backward__contrib_DeformableConvolution_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_ifft(ndarray)" =+     '[ '("compute_size", AttrOpt Int),+        '("data", AttrOpt NDArrayHandle)]++_contrib_ifft ::+              forall args . Fullfilled "_contrib_ifft(ndarray)" args =>+                ArgsHMap "_contrib_ifft(ndarray)" args -> IO [NDArrayHandle]+_contrib_ifft args+  = let scalarArgs+          = catMaybes+              [("compute_size",) . showValue <$>+                 (args !? #compute_size :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_ifft"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_ifft_upd ::+                  forall args . Fullfilled "_contrib_ifft(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_contrib_ifft(ndarray)" args -> IO ()+_contrib_ifft_upd outputs args+  = let scalarArgs+          = catMaybes+              [("compute_size",) . showValue <$>+                 (args !? #compute_size :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_ifft"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward__contrib_ifft(ndarray)" =+     '[]++_backward__contrib_ifft ::+                        forall args . Fullfilled "_backward__contrib_ifft(ndarray)" args =>+                          ArgsHMap "_backward__contrib_ifft(ndarray)" args ->+                            IO [NDArrayHandle]+_backward__contrib_ifft args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_ifft"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_ifft_upd ::+                            forall args . Fullfilled "_backward__contrib_ifft(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward__contrib_ifft(ndarray)" args -> IO ()+_backward__contrib_ifft_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_ifft"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward__contrib_SyncBatchNorm(ndarray)" = '[]++_backward__contrib_SyncBatchNorm ::+                                 forall args .+                                   Fullfilled "_backward__contrib_SyncBatchNorm(ndarray)" args =>+                                   ArgsHMap "_backward__contrib_SyncBatchNorm(ndarray)" args ->+                                     IO [NDArrayHandle]+_backward__contrib_SyncBatchNorm args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_SyncBatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_SyncBatchNorm_upd ::+                                     forall args .+                                       Fullfilled "_backward__contrib_SyncBatchNorm(ndarray)"+                                         args =>+                                       [NDArrayHandle] ->+                                         ArgsHMap "_backward__contrib_SyncBatchNorm(ndarray)" args+                                           -> IO ()+_backward__contrib_SyncBatchNorm_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_SyncBatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_InstanceNorm(ndarray)" =+     '[ '("eps", AttrOpt Float), '("data", AttrOpt NDArrayHandle),+        '("gamma", AttrOpt NDArrayHandle),+        '("beta", AttrOpt NDArrayHandle)]++_InstanceNorm ::+              forall args . Fullfilled "_InstanceNorm(ndarray)" args =>+                ArgsHMap "_InstanceNorm(ndarray)" args -> IO [NDArrayHandle]+_InstanceNorm args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "InstanceNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_InstanceNorm_upd ::+                  forall args . Fullfilled "_InstanceNorm(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_InstanceNorm(ndarray)" args -> IO ()+_InstanceNorm_upd outputs args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "InstanceNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_InstanceNorm(ndarray)" = '[]++_backward_InstanceNorm ::+                       forall args . Fullfilled "_backward_InstanceNorm(ndarray)" args =>+                         ArgsHMap "_backward_InstanceNorm(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_InstanceNorm args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_InstanceNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_InstanceNorm_upd ::+                           forall args . Fullfilled "_backward_InstanceNorm(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_InstanceNorm(ndarray)" args -> IO ()+_backward_InstanceNorm_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_InstanceNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_SVMOutput(ndarray)" =+     '[ '("margin", AttrOpt Float),+        '("regularization_coefficient", AttrOpt Float),+        '("use_linear", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),+        '("label", AttrOpt NDArrayHandle)]++_SVMOutput ::+           forall args . Fullfilled "_SVMOutput(ndarray)" args =>+             ArgsHMap "_SVMOutput(ndarray)" args -> IO [NDArrayHandle]+_SVMOutput args+  = let scalarArgs+          = catMaybes+              [("margin",) . showValue <$> (args !? #margin :: Maybe Float),+               ("regularization_coefficient",) . showValue <$>+                 (args !? #regularization_coefficient :: Maybe Float),+               ("use_linear",) . showValue <$>+                 (args !? #use_linear :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SVMOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_SVMOutput_upd ::+               forall args . Fullfilled "_SVMOutput(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "_SVMOutput(ndarray)" args -> IO ()+_SVMOutput_upd outputs args+  = let scalarArgs+          = catMaybes+              [("margin",) . showValue <$> (args !? #margin :: Maybe Float),+               ("regularization_coefficient",) . showValue <$>+                 (args !? #regularization_coefficient :: Maybe Float),+               ("use_linear",) . showValue <$>+                 (args !? #use_linear :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SVMOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SVMOutput(ndarray)" = '[]++_backward_SVMOutput ::+                    forall args . Fullfilled "_backward_SVMOutput(ndarray)" args =>+                      ArgsHMap "_backward_SVMOutput(ndarray)" args -> IO [NDArrayHandle]+_backward_SVMOutput args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SVMOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SVMOutput_upd ::+                        forall args . Fullfilled "_backward_SVMOutput(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_backward_SVMOutput(ndarray)" args -> IO ()+_backward_SVMOutput_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SVMOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_GridGenerator(ndarray)" =+     '[ '("transform_type", AttrReq (EnumType '["affine", "warp"])),+        '("target_shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]++_GridGenerator ::+               forall args . Fullfilled "_GridGenerator(ndarray)" args =>+                 ArgsHMap "_GridGenerator(ndarray)" args -> IO [NDArrayHandle]+_GridGenerator args+  = let scalarArgs+          = catMaybes+              [("transform_type",) . showValue <$>+                 (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "GridGenerator"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_GridGenerator_upd ::+                   forall args . Fullfilled "_GridGenerator(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_GridGenerator(ndarray)" args -> IO ()+_GridGenerator_upd outputs args+  = let scalarArgs+          = catMaybes+              [("transform_type",) . showValue <$>+                 (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "GridGenerator"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_GridGenerator(ndarray)" =+     '[]++_backward_GridGenerator ::+                        forall args . Fullfilled "_backward_GridGenerator(ndarray)" args =>+                          ArgsHMap "_backward_GridGenerator(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_GridGenerator args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_GridGenerator"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_GridGenerator_upd ::+                            forall args . Fullfilled "_backward_GridGenerator(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_GridGenerator(ndarray)" args -> IO ()+_backward_GridGenerator_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_GridGenerator"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Pad(ndarray)" = '[]++_backward_Pad ::+              forall args . Fullfilled "_backward_Pad(ndarray)" args =>+                ArgsHMap "_backward_Pad(ndarray)" args -> IO [NDArrayHandle]+_backward_Pad args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pad"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Pad_upd ::+                  forall args . Fullfilled "_backward_Pad(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_Pad(ndarray)" args -> IO ()+_backward_Pad_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pad"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Convolution_v1(ndarray)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("cudnn_tune",+          AttrOpt+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+        '("cudnn_off", AttrOpt Bool),+        '("layout",+          AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"]))),+        '("data", AttrOpt NDArrayHandle),+        '("weight", AttrOpt NDArrayHandle),+        '("bias", AttrOpt NDArrayHandle)]++_Convolution_v1 ::+                forall args . Fullfilled "_Convolution_v1(ndarray)" args =>+                  ArgsHMap "_Convolution_v1(ndarray)" args -> IO [NDArrayHandle]+_Convolution_v1 args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Convolution_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Convolution_v1_upd ::+                    forall args . Fullfilled "_Convolution_v1(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_Convolution_v1(ndarray)" args -> IO ()+_Convolution_v1_upd outputs args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Convolution_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Convolution_v1(ndarray)" =+     '[]++_backward_Convolution_v1 ::+                         forall args .+                           Fullfilled "_backward_Convolution_v1(ndarray)" args =>+                           ArgsHMap "_backward_Convolution_v1(ndarray)" args ->+                             IO [NDArrayHandle]+_backward_Convolution_v1 args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Convolution_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Convolution_v1_upd ::+                             forall args .+                               Fullfilled "_backward_Convolution_v1(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_backward_Convolution_v1(ndarray)" args -> IO ()+_backward_Convolution_v1_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Convolution_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_SequenceReverse(ndarray)" =+     '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int),+        '("data", AttrOpt NDArrayHandle),+        '("sequence_length", AttrOpt NDArrayHandle)]++_SequenceReverse ::+                 forall args . Fullfilled "_SequenceReverse(ndarray)" args =>+                   ArgsHMap "_SequenceReverse(ndarray)" args -> IO [NDArrayHandle]+_SequenceReverse args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceReverse"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_SequenceReverse_upd ::+                     forall args . Fullfilled "_SequenceReverse(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_SequenceReverse(ndarray)" args -> IO ()+_SequenceReverse_upd outputs args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceReverse"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SequenceReverse(ndarray)" =+     '[]++_backward_SequenceReverse ::+                          forall args .+                            Fullfilled "_backward_SequenceReverse(ndarray)" args =>+                            ArgsHMap "_backward_SequenceReverse(ndarray)" args ->+                              IO [NDArrayHandle]+_backward_SequenceReverse args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceReverse"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SequenceReverse_upd ::+                              forall args .+                                Fullfilled "_backward_SequenceReverse(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_backward_SequenceReverse(ndarray)" args -> IO ()+_backward_SequenceReverse_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceReverse"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_SoftmaxOutput(ndarray)" =+     '[ '("grad_scale", AttrOpt Float),+        '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool),+        '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool),+        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),+        '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle),+        '("label", AttrOpt NDArrayHandle)]++_SoftmaxOutput ::+               forall args . Fullfilled "_SoftmaxOutput(ndarray)" args =>+                 ArgsHMap "_SoftmaxOutput(ndarray)" args -> IO [NDArrayHandle]+_SoftmaxOutput args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float),+               ("ignore_label",) . showValue <$>+                 (args !? #ignore_label :: Maybe Float),+               ("multi_output",) . showValue <$>+                 (args !? #multi_output :: Maybe Bool),+               ("use_ignore",) . showValue <$>+                 (args !? #use_ignore :: Maybe Bool),+               ("preserve_shape",) . showValue <$>+                 (args !? #preserve_shape :: Maybe Bool),+               ("normalization",) . showValue <$>+                 (args !? #normalization ::+                    Maybe (EnumType '["batch", "null", "valid"])),+               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),+               ("smooth_alpha",) . showValue <$>+                 (args !? #smooth_alpha :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SoftmaxOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_SoftmaxOutput_upd ::+                   forall args . Fullfilled "_SoftmaxOutput(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_SoftmaxOutput(ndarray)" args -> IO ()+_SoftmaxOutput_upd outputs args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float),+               ("ignore_label",) . showValue <$>+                 (args !? #ignore_label :: Maybe Float),+               ("multi_output",) . showValue <$>+                 (args !? #multi_output :: Maybe Bool),+               ("use_ignore",) . showValue <$>+                 (args !? #use_ignore :: Maybe Bool),+               ("preserve_shape",) . showValue <$>+                 (args !? #preserve_shape :: Maybe Bool),+               ("normalization",) . showValue <$>+                 (args !? #normalization ::+                    Maybe (EnumType '["batch", "null", "valid"])),+               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),+               ("smooth_alpha",) . showValue <$>+                 (args !? #smooth_alpha :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SoftmaxOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SoftmaxOutput(ndarray)" =+     '[]++_backward_SoftmaxOutput ::+                        forall args . Fullfilled "_backward_SoftmaxOutput(ndarray)" args =>+                          ArgsHMap "_backward_SoftmaxOutput(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_SoftmaxOutput args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SoftmaxOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SoftmaxOutput_upd ::+                            forall args . Fullfilled "_backward_SoftmaxOutput(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_SoftmaxOutput(ndarray)" args -> IO ()+_backward_SoftmaxOutput_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SoftmaxOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Softmax(ndarray)" =+     '[ '("grad_scale", AttrOpt Float),+        '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool),+        '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool),+        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),+        '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle)]++_Softmax ::+         forall args . Fullfilled "_Softmax(ndarray)" args =>+           ArgsHMap "_Softmax(ndarray)" args -> IO [NDArrayHandle]+_Softmax args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float),+               ("ignore_label",) . showValue <$>+                 (args !? #ignore_label :: Maybe Float),+               ("multi_output",) . showValue <$>+                 (args !? #multi_output :: Maybe Bool),+               ("use_ignore",) . showValue <$>+                 (args !? #use_ignore :: Maybe Bool),+               ("preserve_shape",) . showValue <$>+                 (args !? #preserve_shape :: Maybe Bool),+               ("normalization",) . showValue <$>+                 (args !? #normalization ::+                    Maybe (EnumType '["batch", "null", "valid"])),+               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),+               ("smooth_alpha",) . showValue <$>+                 (args !? #smooth_alpha :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Softmax_upd ::+             forall args . Fullfilled "_Softmax(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "_Softmax(ndarray)" args -> IO ()+_Softmax_upd outputs args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float),+               ("ignore_label",) . showValue <$>+                 (args !? #ignore_label :: Maybe Float),+               ("multi_output",) . showValue <$>+                 (args !? #multi_output :: Maybe Bool),+               ("use_ignore",) . showValue <$>+                 (args !? #use_ignore :: Maybe Bool),+               ("preserve_shape",) . showValue <$>+                 (args !? #preserve_shape :: Maybe Bool),+               ("normalization",) . showValue <$>+                 (args !? #normalization ::+                    Maybe (EnumType '["batch", "null", "valid"])),+               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),+               ("smooth_alpha",) . showValue <$>+                 (args !? #smooth_alpha :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Softmax(ndarray)" = '[]++_backward_Softmax ::+                  forall args . Fullfilled "_backward_Softmax(ndarray)" args =>+                    ArgsHMap "_backward_Softmax(ndarray)" args -> IO [NDArrayHandle]+_backward_Softmax args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Softmax_upd ::+                      forall args . Fullfilled "_backward_Softmax(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_Softmax(ndarray)" args -> IO ()+_backward_Softmax_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_BilinearSampler(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle),+        '("grid", AttrOpt NDArrayHandle)]++_BilinearSampler ::+                 forall args . Fullfilled "_BilinearSampler(ndarray)" args =>+                   ArgsHMap "_BilinearSampler(ndarray)" args -> IO [NDArrayHandle]+_BilinearSampler args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("grid",) <$> (args !? #grid :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BilinearSampler"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_BilinearSampler_upd ::+                     forall args . Fullfilled "_BilinearSampler(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_BilinearSampler(ndarray)" args -> IO ()+_BilinearSampler_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("grid",) <$> (args !? #grid :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BilinearSampler"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_BilinearSampler(ndarray)" =+     '[]++_backward_BilinearSampler ::+                          forall args .+                            Fullfilled "_backward_BilinearSampler(ndarray)" args =>+                            ArgsHMap "_backward_BilinearSampler(ndarray)" args ->+                              IO [NDArrayHandle]+_backward_BilinearSampler args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BilinearSampler"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_BilinearSampler_upd ::+                              forall args .+                                Fullfilled "_backward_BilinearSampler(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_backward_BilinearSampler(ndarray)" args -> IO ()+_backward_BilinearSampler_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BilinearSampler"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_LeakyReLU(ndarray)" = '[]++_backward_LeakyReLU ::+                    forall args . Fullfilled "_backward_LeakyReLU(ndarray)" args =>+                      ArgsHMap "_backward_LeakyReLU(ndarray)" args -> IO [NDArrayHandle]+_backward_LeakyReLU args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LeakyReLU"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_LeakyReLU_upd ::+                        forall args . Fullfilled "_backward_LeakyReLU(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_backward_LeakyReLU(ndarray)" args -> IO ()+_backward_LeakyReLU_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LeakyReLU"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Crop(ndarray)" =+     '[ '("num_args", AttrReq Int), '("offset", AttrOpt [Int]),+        '("h_w", AttrOpt [Int]), '("center_crop", AttrOpt Bool),+        '("data", AttrOpt [NDArrayHandle])]++_Crop ::+      forall args . Fullfilled "_Crop(ndarray)" args =>+        ArgsHMap "_Crop(ndarray)" args -> IO [NDArrayHandle]+_Crop args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]),+               ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]),+               ("center_crop",) . showValue <$>+                 (args !? #center_crop :: Maybe Bool)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "Crop"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        Nothing+         return listndarr++_Crop_upd ::+          forall args . Fullfilled "_Crop(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "_Crop(ndarray)" args -> IO ()+_Crop_upd outputs args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]),+               ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]),+               ("center_crop",) . showValue <$>+                 (args !? #center_crop :: Maybe Bool)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "Crop"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Crop(ndarray)" = '[]++_backward_Crop ::+               forall args . Fullfilled "_backward_Crop(ndarray)" args =>+                 ArgsHMap "_backward_Crop(ndarray)" args -> IO [NDArrayHandle]+_backward_Crop args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Crop"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Crop_upd ::+                   forall args . Fullfilled "_backward_Crop(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_Crop(ndarray)" args -> IO ()+_backward_Crop_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Crop"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_ROIPooling(ndarray)" =+     '[ '("pooled_size", AttrReq [Int]),+        '("spatial_scale", AttrReq Float),+        '("data", AttrOpt NDArrayHandle), '("rois", AttrOpt NDArrayHandle)]++_ROIPooling ::+            forall args . Fullfilled "_ROIPooling(ndarray)" args =>+              ArgsHMap "_ROIPooling(ndarray)" args -> IO [NDArrayHandle]+_ROIPooling args+  = let scalarArgs+          = catMaybes+              [("pooled_size",) . showValue <$>+                 (args !? #pooled_size :: Maybe [Int]),+               ("spatial_scale",) . showValue <$>+                 (args !? #spatial_scale :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ROIPooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_ROIPooling_upd ::+                forall args . Fullfilled "_ROIPooling(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_ROIPooling(ndarray)" args -> IO ()+_ROIPooling_upd outputs args+  = let scalarArgs+          = catMaybes+              [("pooled_size",) . showValue <$>+                 (args !? #pooled_size :: Maybe [Int]),+               ("spatial_scale",) . showValue <$>+                 (args !? #spatial_scale :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ROIPooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_ROIPooling(ndarray)" = '[]++_backward_ROIPooling ::+                     forall args . Fullfilled "_backward_ROIPooling(ndarray)" args =>+                       ArgsHMap "_backward_ROIPooling(ndarray)" args -> IO [NDArrayHandle]+_backward_ROIPooling args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_ROIPooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_ROIPooling_upd ::+                         forall args . Fullfilled "_backward_ROIPooling(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_ROIPooling(ndarray)" args -> IO ()+_backward_ROIPooling_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_ROIPooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_SequenceLast(ndarray)" =+     '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int),+        '("data", AttrOpt NDArrayHandle),+        '("sequence_length", AttrOpt NDArrayHandle)]++_SequenceLast ::+              forall args . Fullfilled "_SequenceLast(ndarray)" args =>+                ArgsHMap "_SequenceLast(ndarray)" args -> IO [NDArrayHandle]+_SequenceLast args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceLast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_SequenceLast_upd ::+                  forall args . Fullfilled "_SequenceLast(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_SequenceLast(ndarray)" args -> IO ()+_SequenceLast_upd outputs args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceLast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SequenceLast(ndarray)" = '[]++_backward_SequenceLast ::+                       forall args . Fullfilled "_backward_SequenceLast(ndarray)" args =>+                         ArgsHMap "_backward_SequenceLast(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_SequenceLast args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceLast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SequenceLast_upd ::+                           forall args . Fullfilled "_backward_SequenceLast(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_SequenceLast(ndarray)" args -> IO ()+_backward_SequenceLast_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceLast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_CrossDeviceCopy(ndarray)" = '[]++_CrossDeviceCopy ::+                 forall args . Fullfilled "_CrossDeviceCopy(ndarray)" args =>+                   ArgsHMap "_CrossDeviceCopy(ndarray)" args -> IO [NDArrayHandle]+_CrossDeviceCopy args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_CrossDeviceCopy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_CrossDeviceCopy_upd ::+                     forall args . Fullfilled "_CrossDeviceCopy(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_CrossDeviceCopy(ndarray)" args -> IO ()+_CrossDeviceCopy_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_CrossDeviceCopy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward__CrossDeviceCopy(ndarray)" =+     '[]++_backward__CrossDeviceCopy ::+                           forall args .+                             Fullfilled "_backward__CrossDeviceCopy(ndarray)" args =>+                             ArgsHMap "_backward__CrossDeviceCopy(ndarray)" args ->+                               IO [NDArrayHandle]+_backward__CrossDeviceCopy args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__CrossDeviceCopy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__CrossDeviceCopy_upd ::+                               forall args .+                                 Fullfilled "_backward__CrossDeviceCopy(ndarray)" args =>+                                 [NDArrayHandle] ->+                                   ArgsHMap "_backward__CrossDeviceCopy(ndarray)" args -> IO ()+_backward__CrossDeviceCopy_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__CrossDeviceCopy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_SpatialTransformer(ndarray)" =+     '[ '("target_shape", AttrOpt [Int]),+        '("transform_type", AttrReq (EnumType '["affine"])),+        '("sampler_type", AttrReq (EnumType '["bilinear"])),+        '("data", AttrOpt NDArrayHandle), '("loc", AttrOpt NDArrayHandle)]++_SpatialTransformer ::+                    forall args . Fullfilled "_SpatialTransformer(ndarray)" args =>+                      ArgsHMap "_SpatialTransformer(ndarray)" args -> IO [NDArrayHandle]+_SpatialTransformer args+  = let scalarArgs+          = catMaybes+              [("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("transform_type",) . showValue <$>+                 (args !? #transform_type :: Maybe (EnumType '["affine"])),+               ("sampler_type",) . showValue <$>+                 (args !? #sampler_type :: Maybe (EnumType '["bilinear"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("loc",) <$> (args !? #loc :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SpatialTransformer"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_SpatialTransformer_upd ::+                        forall args . Fullfilled "_SpatialTransformer(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_SpatialTransformer(ndarray)" args -> IO ()+_SpatialTransformer_upd outputs args+  = let scalarArgs+          = catMaybes+              [("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("transform_type",) . showValue <$>+                 (args !? #transform_type :: Maybe (EnumType '["affine"])),+               ("sampler_type",) . showValue <$>+                 (args !? #sampler_type :: Maybe (EnumType '["bilinear"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("loc",) <$> (args !? #loc :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SpatialTransformer"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SpatialTransformer(ndarray)"+     = '[]++_backward_SpatialTransformer ::+                             forall args .+                               Fullfilled "_backward_SpatialTransformer(ndarray)" args =>+                               ArgsHMap "_backward_SpatialTransformer(ndarray)" args ->+                                 IO [NDArrayHandle]+_backward_SpatialTransformer args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SpatialTransformer"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SpatialTransformer_upd ::+                                 forall args .+                                   Fullfilled "_backward_SpatialTransformer(ndarray)" args =>+                                   [NDArrayHandle] ->+                                     ArgsHMap "_backward_SpatialTransformer(ndarray)" args -> IO ()+_backward_SpatialTransformer_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SpatialTransformer"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SwapAxis(ndarray)" = '[]++_backward_SwapAxis ::+                   forall args . Fullfilled "_backward_SwapAxis(ndarray)" args =>+                     ArgsHMap "_backward_SwapAxis(ndarray)" args -> IO [NDArrayHandle]+_backward_SwapAxis args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SwapAxis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SwapAxis_upd ::+                       forall args . Fullfilled "_backward_SwapAxis(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_backward_SwapAxis(ndarray)" args -> IO ()+_backward_SwapAxis_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SwapAxis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_L2Normalization(ndarray)" =+     '[ '("eps", AttrOpt Float),+        '("mode", AttrOpt (EnumType '["channel", "instance", "spatial"])),+        '("data", AttrOpt NDArrayHandle)]++_L2Normalization ::+                 forall args . Fullfilled "_L2Normalization(ndarray)" args =>+                   ArgsHMap "_L2Normalization(ndarray)" args -> IO [NDArrayHandle]+_L2Normalization args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["channel", "instance", "spatial"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "L2Normalization"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_L2Normalization_upd ::+                     forall args . Fullfilled "_L2Normalization(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_L2Normalization(ndarray)" args -> IO ()+_L2Normalization_upd outputs args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["channel", "instance", "spatial"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "L2Normalization"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_L2Normalization(ndarray)" =+     '[]++_backward_L2Normalization ::+                          forall args .+                            Fullfilled "_backward_L2Normalization(ndarray)" args =>+                            ArgsHMap "_backward_L2Normalization(ndarray)" args ->+                              IO [NDArrayHandle]+_backward_L2Normalization args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_L2Normalization"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_L2Normalization_upd ::+                              forall args .+                                Fullfilled "_backward_L2Normalization(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_backward_L2Normalization(ndarray)" args -> IO ()+_backward_L2Normalization_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_L2Normalization"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Correlation(ndarray)" =+     '[ '("kernel_size", AttrOpt Int),+        '("max_displacement", AttrOpt Int), '("stride1", AttrOpt Int),+        '("stride2", AttrOpt Int), '("pad_size", AttrOpt Int),+        '("is_multiply", AttrOpt Bool), '("data1", AttrOpt NDArrayHandle),+        '("data2", AttrOpt NDArrayHandle)]++_Correlation ::+             forall args . Fullfilled "_Correlation(ndarray)" args =>+               ArgsHMap "_Correlation(ndarray)" args -> IO [NDArrayHandle]+_Correlation args+  = let scalarArgs+          = catMaybes+              [("kernel_size",) . showValue <$>+                 (args !? #kernel_size :: Maybe Int),+               ("max_displacement",) . showValue <$>+                 (args !? #max_displacement :: Maybe Int),+               ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int),+               ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int),+               ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int),+               ("is_multiply",) . showValue <$>+                 (args !? #is_multiply :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data1",) <$> (args !? #data1 :: Maybe NDArrayHandle),+               ("data2",) <$> (args !? #data2 :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Correlation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Correlation_upd ::+                 forall args . Fullfilled "_Correlation(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_Correlation(ndarray)" args -> IO ()+_Correlation_upd outputs args+  = let scalarArgs+          = catMaybes+              [("kernel_size",) . showValue <$>+                 (args !? #kernel_size :: Maybe Int),+               ("max_displacement",) . showValue <$>+                 (args !? #max_displacement :: Maybe Int),+               ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int),+               ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int),+               ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int),+               ("is_multiply",) . showValue <$>+                 (args !? #is_multiply :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data1",) <$> (args !? #data1 :: Maybe NDArrayHandle),+               ("data2",) <$> (args !? #data2 :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Correlation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Correlation(ndarray)" = '[]++_backward_Correlation ::+                      forall args . Fullfilled "_backward_Correlation(ndarray)" args =>+                        ArgsHMap "_backward_Correlation(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_Correlation args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Correlation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Correlation_upd ::+                          forall args . Fullfilled "_backward_Correlation(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_Correlation(ndarray)" args -> IO ()+_backward_Correlation_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Correlation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward_IdentityAttachKLSparseReg(ndarray)" = '[]++_backward_IdentityAttachKLSparseReg ::+                                    forall args .+                                      Fullfilled "_backward_IdentityAttachKLSparseReg(ndarray)"+                                        args =>+                                      ArgsHMap "_backward_IdentityAttachKLSparseReg(ndarray)" args+                                        -> IO [NDArrayHandle]+_backward_IdentityAttachKLSparseReg args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_IdentityAttachKLSparseReg_upd ::+                                        forall args .+                                          Fullfilled "_backward_IdentityAttachKLSparseReg(ndarray)"+                                            args =>+                                          [NDArrayHandle] ->+                                            ArgsHMap "_backward_IdentityAttachKLSparseReg(ndarray)"+                                              args+                                              -> IO ()+_backward_IdentityAttachKLSparseReg_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_MakeLoss(ndarray)" =+     '[ '("grad_scale", AttrOpt Float),+        '("valid_thresh", AttrOpt Float),+        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),+        '("data", AttrOpt NDArrayHandle)]++_MakeLoss ::+          forall args . Fullfilled "_MakeLoss(ndarray)" args =>+            ArgsHMap "_MakeLoss(ndarray)" args -> IO [NDArrayHandle]+_MakeLoss args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float),+               ("valid_thresh",) . showValue <$>+                 (args !? #valid_thresh :: Maybe Float),+               ("normalization",) . showValue <$>+                 (args !? #normalization ::+                    Maybe (EnumType '["batch", "null", "valid"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "MakeLoss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_MakeLoss_upd ::+              forall args . Fullfilled "_MakeLoss(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "_MakeLoss(ndarray)" args -> IO ()+_MakeLoss_upd outputs args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float),+               ("valid_thresh",) . showValue <$>+                 (args !? #valid_thresh :: Maybe Float),+               ("normalization",) . showValue <$>+                 (args !? #normalization ::+                    Maybe (EnumType '["batch", "null", "valid"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "MakeLoss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_MakeLoss(ndarray)" = '[]++_backward_MakeLoss ::+                   forall args . Fullfilled "_backward_MakeLoss(ndarray)" args =>+                     ArgsHMap "_backward_MakeLoss(ndarray)" args -> IO [NDArrayHandle]+_backward_MakeLoss args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_MakeLoss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_MakeLoss_upd ::+                       forall args . Fullfilled "_backward_MakeLoss(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_backward_MakeLoss(ndarray)" args -> IO ()+_backward_MakeLoss_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_MakeLoss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SliceChannel(ndarray)" = '[]++_backward_SliceChannel ::+                       forall args . Fullfilled "_backward_SliceChannel(ndarray)" args =>+                         ArgsHMap "_backward_SliceChannel(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_SliceChannel args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SliceChannel"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SliceChannel_upd ::+                           forall args . Fullfilled "_backward_SliceChannel(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_SliceChannel(ndarray)" args -> IO ()+_backward_SliceChannel_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SliceChannel"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_RNN(ndarray)" =+     '[ '("state_size", AttrReq Int), '("num_layers", AttrReq Int),+        '("bidirectional", AttrOpt Bool),+        '("mode",+          AttrReq (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),+        '("p", AttrOpt Float), '("state_outputs", AttrOpt Bool),+        '("data", AttrOpt NDArrayHandle),+        '("parameters", AttrOpt NDArrayHandle),+        '("state", AttrOpt NDArrayHandle),+        '("state_cell", AttrOpt NDArrayHandle)]++_RNN ::+     forall args . Fullfilled "_RNN(ndarray)" args =>+       ArgsHMap "_RNN(ndarray)" args -> IO [NDArrayHandle]+_RNN args+  = let scalarArgs+          = catMaybes+              [("state_size",) . showValue <$>+                 (args !? #state_size :: Maybe Int),+               ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int),+               ("bidirectional",) . showValue <$>+                 (args !? #bidirectional :: Maybe Bool),+               ("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),+               ("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("state_outputs",) . showValue <$>+                 (args !? #state_outputs :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("parameters",) <$> (args !? #parameters :: Maybe NDArrayHandle),+               ("state",) <$> (args !? #state :: Maybe NDArrayHandle),+               ("state_cell",) <$> (args !? #state_cell :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "RNN"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_RNN_upd ::+         forall args . Fullfilled "_RNN(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "_RNN(ndarray)" args -> IO ()+_RNN_upd outputs args+  = let scalarArgs+          = catMaybes+              [("state_size",) . showValue <$>+                 (args !? #state_size :: Maybe Int),+               ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int),+               ("bidirectional",) . showValue <$>+                 (args !? #bidirectional :: Maybe Bool),+               ("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),+               ("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("state_outputs",) . showValue <$>+                 (args !? #state_outputs :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("parameters",) <$> (args !? #parameters :: Maybe NDArrayHandle),+               ("state",) <$> (args !? #state :: Maybe NDArrayHandle),+               ("state_cell",) <$> (args !? #state_cell :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "RNN"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_RNN(ndarray)" = '[]++_backward_RNN ::+              forall args . Fullfilled "_backward_RNN(ndarray)" args =>+                ArgsHMap "_backward_RNN(ndarray)" args -> IO [NDArrayHandle]+_backward_RNN args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_RNN"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_RNN_upd ::+                  forall args . Fullfilled "_backward_RNN(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_RNN(ndarray)" args -> IO ()+_backward_RNN_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_RNN"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Pooling_v1(ndarray)" =+     '[ '("kernel", AttrOpt [Int]),+        '("pool_type", AttrOpt (EnumType '["avg", "max", "sum"])),+        '("global_pool", AttrOpt Bool),+        '("pooling_convention", AttrOpt (EnumType '["full", "valid"])),+        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("data", AttrOpt NDArrayHandle)]++_Pooling_v1 ::+            forall args . Fullfilled "_Pooling_v1(ndarray)" args =>+              ArgsHMap "_Pooling_v1(ndarray)" args -> IO [NDArrayHandle]+_Pooling_v1 args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("pool_type",) . showValue <$>+                 (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])),+               ("global_pool",) . showValue <$>+                 (args !? #global_pool :: Maybe Bool),+               ("pooling_convention",) . showValue <$>+                 (args !? #pooling_convention ::+                    Maybe (EnumType '["full", "valid"])),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pooling_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Pooling_v1_upd ::+                forall args . Fullfilled "_Pooling_v1(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_Pooling_v1(ndarray)" args -> IO ()+_Pooling_v1_upd outputs args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("pool_type",) . showValue <$>+                 (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])),+               ("global_pool",) . showValue <$>+                 (args !? #global_pool :: Maybe Bool),+               ("pooling_convention",) . showValue <$>+                 (args !? #pooling_convention ::+                    Maybe (EnumType '["full", "valid"])),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pooling_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Pooling_v1(ndarray)" = '[]++_backward_Pooling_v1 ::+                     forall args . Fullfilled "_backward_Pooling_v1(ndarray)" args =>+                       ArgsHMap "_backward_Pooling_v1(ndarray)" args -> IO [NDArrayHandle]+_backward_Pooling_v1 args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pooling_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Pooling_v1_upd ::+                         forall args . Fullfilled "_backward_Pooling_v1(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_Pooling_v1(ndarray)" args -> IO ()+_backward_Pooling_v1_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pooling_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_BatchNorm_v1(ndarray)" = '[]++_backward_BatchNorm_v1 ::+                       forall args . Fullfilled "_backward_BatchNorm_v1(ndarray)" args =>+                         ArgsHMap "_backward_BatchNorm_v1(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_BatchNorm_v1 args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BatchNorm_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_BatchNorm_v1_upd ::+                           forall args . Fullfilled "_backward_BatchNorm_v1(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_BatchNorm_v1(ndarray)" args -> IO ()+_backward_BatchNorm_v1_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BatchNorm_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_SequenceMask(ndarray)" =+     '[ '("use_sequence_length", AttrOpt Bool),+        '("value", AttrOpt Float), '("axis", AttrOpt Int),+        '("data", AttrOpt NDArrayHandle),+        '("sequence_length", AttrOpt NDArrayHandle)]++_SequenceMask ::+              forall args . Fullfilled "_SequenceMask(ndarray)" args =>+                ArgsHMap "_SequenceMask(ndarray)" args -> IO [NDArrayHandle]+_SequenceMask args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool),+               ("value",) . showValue <$> (args !? #value :: Maybe Float),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceMask"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_SequenceMask_upd ::+                  forall args . Fullfilled "_SequenceMask(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_SequenceMask(ndarray)" args -> IO ()+_SequenceMask_upd outputs args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool),+               ("value",) . showValue <$> (args !? #value :: Maybe Float),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceMask"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SequenceMask(ndarray)" = '[]++_backward_SequenceMask ::+                       forall args . Fullfilled "_backward_SequenceMask(ndarray)" args =>+                         ArgsHMap "_backward_SequenceMask(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_SequenceMask args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceMask"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SequenceMask_upd ::+                           forall args . Fullfilled "_backward_SequenceMask(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_SequenceMask(ndarray)" args -> IO ()+_backward_SequenceMask_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceMask"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_set_value(ndarray)" =+     '[ '("src", AttrOpt Float)]++_set_value ::+           forall args . Fullfilled "_set_value(ndarray)" args =>+             ArgsHMap "_set_value(ndarray)" args -> IO [NDArrayHandle]+_set_value args+  = let scalarArgs+          = catMaybes+              [("src",) . showValue <$> (args !? #src :: Maybe Float)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_set_value"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_set_value_upd ::+               forall args . Fullfilled "_set_value(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "_set_value(ndarray)" args -> IO ()+_set_value_upd outputs args+  = let scalarArgs+          = catMaybes+              [("src",) . showValue <$> (args !? #src :: Maybe Float)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_set_value"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_onehot_encode(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_onehot_encode ::+               forall args . Fullfilled "_onehot_encode(ndarray)" args =>+                 ArgsHMap "_onehot_encode(ndarray)" args -> IO [NDArrayHandle]+_onehot_encode args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_onehot_encode"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_onehot_encode_upd ::+                   forall args . Fullfilled "_onehot_encode(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_onehot_encode(ndarray)" args -> IO ()+_onehot_encode_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_onehot_encode"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "choose_element_0index(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++choose_element_0index ::+                      forall args . Fullfilled "choose_element_0index(ndarray)" args =>+                        ArgsHMap "choose_element_0index(ndarray)" args ->+                          IO [NDArrayHandle]+choose_element_0index args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "choose_element_0index"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++choose_element_0index_upd ::+                          forall args . Fullfilled "choose_element_0index(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "choose_element_0index(ndarray)" args -> IO ()+choose_element_0index_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "choose_element_0index"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "fill_element_0index(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("mhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]++fill_element_0index ::+                    forall args . Fullfilled "fill_element_0index(ndarray)" args =>+                      ArgsHMap "fill_element_0index(ndarray)" args -> IO [NDArrayHandle]+fill_element_0index args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("mhs",) <$> (args !? #mhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "fill_element_0index"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++fill_element_0index_upd ::+                        forall args . Fullfilled "fill_element_0index(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "fill_element_0index(ndarray)" args -> IO ()+fill_element_0index_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("mhs",) <$> (args !? #mhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "fill_element_0index"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_imdecode(ndarray)" =+     '[ '("index", AttrOpt Int), '("x0", AttrOpt Int),+        '("y0", AttrOpt Int), '("x1", AttrOpt Int), '("y1", AttrOpt Int),+        '("c", AttrOpt Int), '("size", AttrOpt Int),+        '("mean", AttrOpt NDArrayHandle)]++_imdecode ::+          forall args . Fullfilled "_imdecode(ndarray)" args =>+            ArgsHMap "_imdecode(ndarray)" args -> IO [NDArrayHandle]+_imdecode args+  = let scalarArgs+          = catMaybes+              [("index",) . showValue <$> (args !? #index :: Maybe Int),+               ("x0",) . showValue <$> (args !? #x0 :: Maybe Int),+               ("y0",) . showValue <$> (args !? #y0 :: Maybe Int),+               ("x1",) . showValue <$> (args !? #x1 :: Maybe Int),+               ("y1",) . showValue <$> (args !? #y1 :: Maybe Int),+               ("c",) . showValue <$> (args !? #c :: Maybe Int),+               ("size",) . showValue <$> (args !? #size :: Maybe Int)]+        tensorArgs+          = catMaybes [("mean",) <$> (args !? #mean :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_imdecode"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_imdecode_upd ::+              forall args . Fullfilled "_imdecode(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "_imdecode(ndarray)" args -> IO ()+_imdecode_upd outputs args+  = let scalarArgs+          = catMaybes+              [("index",) . showValue <$> (args !? #index :: Maybe Int),+               ("x0",) . showValue <$> (args !? #x0 :: Maybe Int),+               ("y0",) . showValue <$> (args !? #y0 :: Maybe Int),+               ("x1",) . showValue <$> (args !? #x1 :: Maybe Int),+               ("y1",) . showValue <$> (args !? #y1 :: Maybe Int),+               ("c",) . showValue <$> (args !? #c :: Maybe Int),+               ("size",) . showValue <$> (args !? #size :: Maybe Int)]+        tensorArgs+          = catMaybes [("mean",) <$> (args !? #mean :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_imdecode"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()
+ ops/1.3/MXNet/Base/Operators/Symbol.hs view
@@ -0,0 +1,11404 @@+module MXNet.Base.Operators.Symbol where+import MXNet.Base.Raw+import MXNet.Base.Spec.Operator+import MXNet.Base.Spec.HMap+import Data.Maybe (catMaybes, fromMaybe)++type instance ParameterList "_sample_multinomial(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("get_prob", AttrOpt Bool),+        '("dtype",+          AttrOpt+            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),+        '("data", AttrOpt SymbolHandle)]++_sample_multinomial ::+                    forall args . Fullfilled "_sample_multinomial(symbol)" args =>+                      String ->+                        ArgsHMap "_sample_multinomial(symbol)" args -> IO SymbolHandle+_sample_multinomial name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_multinomial"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sample_multinomial(symbol)"+     = '[]++_backward_sample_multinomial ::+                             forall args .+                               Fullfilled "_backward_sample_multinomial(symbol)" args =>+                               String ->+                                 ArgsHMap "_backward_sample_multinomial(symbol)" args ->+                                   IO SymbolHandle+_backward_sample_multinomial name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sample_multinomial"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_uniform(symbol)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("low", AttrOpt SymbolHandle), '("high", AttrOpt SymbolHandle)]++_sample_uniform ::+                forall args . Fullfilled "_sample_uniform(symbol)" args =>+                  String ->+                    ArgsHMap "_sample_uniform(symbol)" args -> IO SymbolHandle+_sample_uniform name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("low",) <$> (args !? #low :: Maybe SymbolHandle),+               ("high",) <$> (args !? #high :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_uniform"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_normal(symbol)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("mu", AttrOpt SymbolHandle), '("sigma", AttrOpt SymbolHandle)]++_sample_normal ::+               forall args . Fullfilled "_sample_normal(symbol)" args =>+                 String -> ArgsHMap "_sample_normal(symbol)" args -> IO SymbolHandle+_sample_normal name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("mu",) <$> (args !? #mu :: Maybe SymbolHandle),+               ("sigma",) <$> (args !? #sigma :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_normal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_gamma(symbol)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("alpha", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle)]++_sample_gamma ::+              forall args . Fullfilled "_sample_gamma(symbol)" args =>+                String -> ArgsHMap "_sample_gamma(symbol)" args -> IO SymbolHandle+_sample_gamma name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("alpha",) <$> (args !? #alpha :: Maybe SymbolHandle),+               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_gamma"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_exponential(symbol)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("lam", AttrOpt SymbolHandle)]++_sample_exponential ::+                    forall args . Fullfilled "_sample_exponential(symbol)" args =>+                      String ->+                        ArgsHMap "_sample_exponential(symbol)" args -> IO SymbolHandle+_sample_exponential name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("lam",) <$> (args !? #lam :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_exponential"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_poisson(symbol)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("lam", AttrOpt SymbolHandle)]++_sample_poisson ::+                forall args . Fullfilled "_sample_poisson(symbol)" args =>+                  String ->+                    ArgsHMap "_sample_poisson(symbol)" args -> IO SymbolHandle+_sample_poisson name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("lam",) <$> (args !? #lam :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_poisson"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_negative_binomial(symbol)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("k", AttrOpt SymbolHandle), '("p", AttrOpt SymbolHandle)]++_sample_negative_binomial ::+                          forall args .+                            Fullfilled "_sample_negative_binomial(symbol)" args =>+                            String ->+                              ArgsHMap "_sample_negative_binomial(symbol)" args ->+                                IO SymbolHandle+_sample_negative_binomial name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("k",) <$> (args !? #k :: Maybe SymbolHandle),+               ("p",) <$> (args !? #p :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_negative_binomial"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_sample_generalized_negative_binomial(symbol)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("mu", AttrOpt SymbolHandle), '("alpha", AttrOpt SymbolHandle)]++_sample_generalized_negative_binomial ::+                                      forall args .+                                        Fullfilled "_sample_generalized_negative_binomial(symbol)"+                                          args =>+                                        String ->+                                          ArgsHMap "_sample_generalized_negative_binomial(symbol)"+                                            args+                                            -> IO SymbolHandle+_sample_generalized_negative_binomial name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("mu",) <$> (args !? #mu :: Maybe SymbolHandle),+               ("alpha",) <$> (args !? #alpha :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_generalized_negative_binomial"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_unique_zipfian(symbol)" =+     '[ '("range_max", AttrReq Int), '("shape", AttrOpt [Int])]++_sample_unique_zipfian ::+                       forall args . Fullfilled "_sample_unique_zipfian(symbol)" args =>+                         String ->+                           ArgsHMap "_sample_unique_zipfian(symbol)" args -> IO SymbolHandle+_sample_unique_zipfian name args+  = let scalarArgs+          = catMaybes+              [("range_max",) . showValue <$> (args !? #range_max :: Maybe Int),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_unique_zipfian"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_uniform(symbol)" =+     '[ '("low", AttrOpt Float), '("high", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_uniform ::+                forall args . Fullfilled "_random_uniform(symbol)" args =>+                  String ->+                    ArgsHMap "_random_uniform(symbol)" args -> IO SymbolHandle+_random_uniform name args+  = let scalarArgs+          = catMaybes+              [("low",) . showValue <$> (args !? #low :: Maybe Float),+               ("high",) . showValue <$> (args !? #high :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_uniform"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_normal(symbol)" =+     '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_normal ::+               forall args . Fullfilled "_random_normal(symbol)" args =>+                 String -> ArgsHMap "_random_normal(symbol)" args -> IO SymbolHandle+_random_normal name args+  = let scalarArgs+          = catMaybes+              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),+               ("scale",) . showValue <$> (args !? #scale :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_normal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_gamma(symbol)" =+     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_gamma ::+              forall args . Fullfilled "_random_gamma(symbol)" args =>+                String -> ArgsHMap "_random_gamma(symbol)" args -> IO SymbolHandle+_random_gamma name args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_gamma"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_exponential(symbol)" =+     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),+        '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_exponential ::+                    forall args . Fullfilled "_random_exponential(symbol)" args =>+                      String ->+                        ArgsHMap "_random_exponential(symbol)" args -> IO SymbolHandle+_random_exponential name args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_exponential"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_poisson(symbol)" =+     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),+        '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_poisson ::+                forall args . Fullfilled "_random_poisson(symbol)" args =>+                  String ->+                    ArgsHMap "_random_poisson(symbol)" args -> IO SymbolHandle+_random_poisson name args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_poisson"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_negative_binomial(symbol)" =+     '[ '("k", AttrOpt Int), '("p", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_negative_binomial ::+                          forall args .+                            Fullfilled "_random_negative_binomial(symbol)" args =>+                            String ->+                              ArgsHMap "_random_negative_binomial(symbol)" args ->+                                IO SymbolHandle+_random_negative_binomial name args+  = let scalarArgs+          = catMaybes+              [("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_negative_binomial"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_random_generalized_negative_binomial(symbol)" =+     '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_generalized_negative_binomial ::+                                      forall args .+                                        Fullfilled "_random_generalized_negative_binomial(symbol)"+                                          args =>+                                        String ->+                                          ArgsHMap "_random_generalized_negative_binomial(symbol)"+                                            args+                                            -> IO SymbolHandle+_random_generalized_negative_binomial name args+  = let scalarArgs+          = catMaybes+              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_generalized_negative_binomial"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_shuffle(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++_shuffle ::+         forall args . Fullfilled "_shuffle(symbol)" args =>+           String -> ArgsHMap "_shuffle(symbol)" args -> IO SymbolHandle+_shuffle name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_shuffle"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Custom(symbol)" =+     '[ '("op_type", AttrOpt String), '("data", AttrOpt [SymbolHandle])]++_Custom ::+        forall args .+          (Fullfilled "_Custom(symbol)" args,+           PopKey (ArgOf "_Custom(symbol)") args "data",+           Dump (PopResult (ArgOf "_Custom(symbol)") args "data")) =>+          String -> ArgsHMap "_Custom(symbol)" args -> IO SymbolHandle+_Custom name args+  = let scalarArgs = dump (pop args #data)+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "Custom"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_backward_Custom(symbol)" = '[]++_backward_Custom ::+                 forall args . Fullfilled "_backward_Custom(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_Custom(symbol)" args -> IO SymbolHandle+_backward_Custom name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Custom"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_power(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_power ::+                forall args . Fullfilled "broadcast_power(symbol)" args =>+                  String ->+                    ArgsHMap "broadcast_power(symbol)" args -> IO SymbolHandle+broadcast_power name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_power"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_power(symbol)" =+     '[]++_backward_broadcast_power ::+                          forall args .+                            Fullfilled "_backward_broadcast_power(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_broadcast_power(symbol)" args ->+                                IO SymbolHandle+_backward_broadcast_power name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_power"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_maximum(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_maximum ::+                  forall args . Fullfilled "broadcast_maximum(symbol)" args =>+                    String ->+                      ArgsHMap "broadcast_maximum(symbol)" args -> IO SymbolHandle+broadcast_maximum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_maximum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_maximum(symbol)" =+     '[]++_backward_broadcast_maximum ::+                            forall args .+                              Fullfilled "_backward_broadcast_maximum(symbol)" args =>+                              String ->+                                ArgsHMap "_backward_broadcast_maximum(symbol)" args ->+                                  IO SymbolHandle+_backward_broadcast_maximum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_maximum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_minimum(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_minimum ::+                  forall args . Fullfilled "broadcast_minimum(symbol)" args =>+                    String ->+                      ArgsHMap "broadcast_minimum(symbol)" args -> IO SymbolHandle+broadcast_minimum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_minimum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_minimum(symbol)" =+     '[]++_backward_broadcast_minimum ::+                            forall args .+                              Fullfilled "_backward_broadcast_minimum(symbol)" args =>+                              String ->+                                ArgsHMap "_backward_broadcast_minimum(symbol)" args ->+                                  IO SymbolHandle+_backward_broadcast_minimum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_minimum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_hypot(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_hypot ::+                forall args . Fullfilled "broadcast_hypot(symbol)" args =>+                  String ->+                    ArgsHMap "broadcast_hypot(symbol)" args -> IO SymbolHandle+broadcast_hypot name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_hypot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_hypot(symbol)" =+     '[]++_backward_broadcast_hypot ::+                          forall args .+                            Fullfilled "_backward_broadcast_hypot(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_broadcast_hypot(symbol)" args ->+                                IO SymbolHandle+_backward_broadcast_hypot name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_hypot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_equal ::+       forall args . Fullfilled "_equal(symbol)" args =>+         String -> ArgsHMap "_equal(symbol)" args -> IO SymbolHandle+_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_not_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_not_equal ::+           forall args . Fullfilled "_not_equal(symbol)" args =>+             String -> ArgsHMap "_not_equal(symbol)" args -> IO SymbolHandle+_not_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_not_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_greater(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_greater ::+         forall args . Fullfilled "_greater(symbol)" args =>+           String -> ArgsHMap "_greater(symbol)" args -> IO SymbolHandle+_greater name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_greater_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_greater_equal ::+               forall args . Fullfilled "_greater_equal(symbol)" args =>+                 String -> ArgsHMap "_greater_equal(symbol)" args -> IO SymbolHandle+_greater_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_lesser(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_lesser ::+        forall args . Fullfilled "_lesser(symbol)" args =>+          String -> ArgsHMap "_lesser(symbol)" args -> IO SymbolHandle+_lesser name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_lesser_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_lesser_equal ::+              forall args . Fullfilled "_lesser_equal(symbol)" args =>+                String -> ArgsHMap "_lesser_equal(symbol)" args -> IO SymbolHandle+_lesser_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_logical_and(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_logical_and ::+             forall args . Fullfilled "_logical_and(symbol)" args =>+               String -> ArgsHMap "_logical_and(symbol)" args -> IO SymbolHandle+_logical_and name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_and"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_logical_or(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_logical_or ::+            forall args . Fullfilled "_logical_or(symbol)" args =>+              String -> ArgsHMap "_logical_or(symbol)" args -> IO SymbolHandle+_logical_or name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_or"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_logical_xor(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_logical_xor ::+             forall args . Fullfilled "_logical_xor(symbol)" args =>+               String -> ArgsHMap "_logical_xor(symbol)" args -> IO SymbolHandle+_logical_xor name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_xor"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_power(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_power ::+       forall args . Fullfilled "_power(symbol)" args =>+         String -> ArgsHMap "_power(symbol)" args -> IO SymbolHandle+_power name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_power"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_power(symbol)" = '[]++_backward_power ::+                forall args . Fullfilled "_backward_power(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_power(symbol)" args -> IO SymbolHandle+_backward_power name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_power"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_maximum(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_maximum ::+         forall args . Fullfilled "_maximum(symbol)" args =>+           String -> ArgsHMap "_maximum(symbol)" args -> IO SymbolHandle+_maximum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_maximum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_maximum(symbol)" = '[]++_backward_maximum ::+                  forall args . Fullfilled "_backward_maximum(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_maximum(symbol)" args -> IO SymbolHandle+_backward_maximum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_maximum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_minimum(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_minimum ::+         forall args . Fullfilled "_minimum(symbol)" args =>+           String -> ArgsHMap "_minimum(symbol)" args -> IO SymbolHandle+_minimum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minimum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_minimum(symbol)" = '[]++_backward_minimum ::+                  forall args . Fullfilled "_backward_minimum(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_minimum(symbol)" args -> IO SymbolHandle+_backward_minimum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_minimum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_hypot(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_hypot ::+       forall args . Fullfilled "_hypot(symbol)" args =>+         String -> ArgsHMap "_hypot(symbol)" args -> IO SymbolHandle+_hypot name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_hypot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_hypot(symbol)" = '[]++_backward_hypot ::+                forall args . Fullfilled "_backward_hypot(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_hypot(symbol)" args -> IO SymbolHandle+_backward_hypot name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_hypot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_square_sum(symbol)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++_square_sum ::+            forall args . Fullfilled "_square_sum(symbol)" args =>+              String -> ArgsHMap "_square_sum(symbol)" args -> IO SymbolHandle+_square_sum name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_square_sum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_square_sum(symbol)" = '[]++_backward_square_sum ::+                     forall args . Fullfilled "_backward_square_sum(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_square_sum(symbol)" args -> IO SymbolHandle+_backward_square_sum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_square_sum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "add_n(symbol)" =+     '[ '("args", AttrOpt [SymbolHandle])]++add_n ::+      forall args . Fullfilled "add_n(symbol)" args =>+        String -> ArgsHMap "add_n(symbol)" args -> IO SymbolHandle+add_n name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "add_n"+         sym <- if hasKey args #num_args then+                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals+                  else+                  mxSymbolCreateAtomicSymbol (fromOpHandle op)+                    ("num_args" : scalarkeys)+                    (showValue (length array) : scalarvals)+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_zeros(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"]))]++_zeros ::+       forall args . Fullfilled "_zeros(symbol)" args =>+         String -> ArgsHMap "_zeros(symbol)" args -> IO SymbolHandle+_zeros name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_zeros"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_eye(symbol)" =+     '[ '("_N", AttrReq Int), '("_M", AttrOpt Int), '("k", AttrOpt Int),+        '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"]))]++_eye ::+     forall args . Fullfilled "_eye(symbol)" args =>+       String -> ArgsHMap "_eye(symbol)" args -> IO SymbolHandle+_eye name args+  = let scalarArgs+          = catMaybes+              [("_N",) . showValue <$> (args !? #_N :: Maybe Int),+               ("_M",) . showValue <$> (args !? #_M :: Maybe Int),+               ("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_eye"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_ones(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"]))]++_ones ::+      forall args . Fullfilled "_ones(symbol)" args =>+        String -> ArgsHMap "_ones(symbol)" args -> IO SymbolHandle+_ones name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_ones"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_full(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("value", AttrReq Double)]++_full ::+      forall args . Fullfilled "_full(symbol)" args =>+        String -> ArgsHMap "_full(symbol)" args -> IO SymbolHandle+_full name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"])),+               ("value",) . showValue <$> (args !? #value :: Maybe Double)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_full"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_arange(symbol)" =+     '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)),+        '("step", AttrOpt Double), '("repeat", AttrOpt Int),+        '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"]))]++_arange ::+        forall args . Fullfilled "_arange(symbol)" args =>+          String -> ArgsHMap "_arange(symbol)" args -> IO SymbolHandle+_arange name args+  = let scalarArgs+          = catMaybes+              [("start",) . showValue <$> (args !? #start :: Maybe Double),+               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),+               ("step",) . showValue <$> (args !? #step :: Maybe Double),+               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_arange"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "zeros_like(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++zeros_like ::+           forall args . Fullfilled "zeros_like(symbol)" args =>+             String -> ArgsHMap "zeros_like(symbol)" args -> IO SymbolHandle+zeros_like name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "zeros_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "ones_like(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++ones_like ::+          forall args . Fullfilled "ones_like(symbol)" args =>+            String -> ArgsHMap "ones_like(symbol)" args -> IO SymbolHandle+ones_like name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ones_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_add(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_add ::+              forall args . Fullfilled "broadcast_add(symbol)" args =>+                String -> ArgsHMap "broadcast_add(symbol)" args -> IO SymbolHandle+broadcast_add name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_add"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_add(symbol)" = '[]++_backward_broadcast_add ::+                        forall args . Fullfilled "_backward_broadcast_add(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_broadcast_add(symbol)" args -> IO SymbolHandle+_backward_broadcast_add name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_add"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_sub(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_sub ::+              forall args . Fullfilled "broadcast_sub(symbol)" args =>+                String -> ArgsHMap "broadcast_sub(symbol)" args -> IO SymbolHandle+broadcast_sub name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_sub"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_sub(symbol)" = '[]++_backward_broadcast_sub ::+                        forall args . Fullfilled "_backward_broadcast_sub(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_broadcast_sub(symbol)" args -> IO SymbolHandle+_backward_broadcast_sub name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_sub"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_mul(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_mul ::+              forall args . Fullfilled "broadcast_mul(symbol)" args =>+                String -> ArgsHMap "broadcast_mul(symbol)" args -> IO SymbolHandle+broadcast_mul name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_mul"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_mul(symbol)" = '[]++_backward_broadcast_mul ::+                        forall args . Fullfilled "_backward_broadcast_mul(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_broadcast_mul(symbol)" args -> IO SymbolHandle+_backward_broadcast_mul name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_mul"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_div(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_div ::+              forall args . Fullfilled "broadcast_div(symbol)" args =>+                String -> ArgsHMap "broadcast_div(symbol)" args -> IO SymbolHandle+broadcast_div name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_div"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_div(symbol)" = '[]++_backward_broadcast_div ::+                        forall args . Fullfilled "_backward_broadcast_div(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_broadcast_div(symbol)" args -> IO SymbolHandle+_backward_broadcast_div name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_div"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_mod(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_mod ::+              forall args . Fullfilled "broadcast_mod(symbol)" args =>+                String -> ArgsHMap "broadcast_mod(symbol)" args -> IO SymbolHandle+broadcast_mod name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_mod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_mod(symbol)" = '[]++_backward_broadcast_mod ::+                        forall args . Fullfilled "_backward_broadcast_mod(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_broadcast_mod(symbol)" args -> IO SymbolHandle+_backward_broadcast_mod name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_mod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_gemm(symbol)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("alpha", AttrOpt Double), '("beta", AttrOpt Double),+        '("axis", AttrOpt Int), '("_A", AttrOpt SymbolHandle),+        '("_B", AttrOpt SymbolHandle), '("_C", AttrOpt SymbolHandle)]++_linalg_gemm ::+             forall args . Fullfilled "_linalg_gemm(symbol)" args =>+               String -> ArgsHMap "_linalg_gemm(symbol)" args -> IO SymbolHandle+_linalg_gemm name args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Double),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),+               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle),+               ("_C",) <$> (args !? #_C :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gemm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_gemm(symbol)" = '[]++_backward_linalg_gemm ::+                      forall args . Fullfilled "_backward_linalg_gemm(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_linalg_gemm(symbol)" args -> IO SymbolHandle+_backward_linalg_gemm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gemm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_gemm2(symbol)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("alpha", AttrOpt Double), '("axis", AttrOpt Int),+        '("_A", AttrOpt SymbolHandle), '("_B", AttrOpt SymbolHandle)]++_linalg_gemm2 ::+              forall args . Fullfilled "_linalg_gemm2(symbol)" args =>+                String -> ArgsHMap "_linalg_gemm2(symbol)" args -> IO SymbolHandle+_linalg_gemm2 name args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),+               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gemm2"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_gemm2(symbol)" = '[]++_backward_linalg_gemm2 ::+                       forall args . Fullfilled "_backward_linalg_gemm2(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_linalg_gemm2(symbol)" args -> IO SymbolHandle+_backward_linalg_gemm2 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gemm2"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_potrf(symbol)" =+     '[ '("_A", AttrOpt SymbolHandle)]++_linalg_potrf ::+              forall args . Fullfilled "_linalg_potrf(symbol)" args =>+                String -> ArgsHMap "_linalg_potrf(symbol)" args -> IO SymbolHandle+_linalg_potrf name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_potrf"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_potrf(symbol)" = '[]++_backward_linalg_potrf ::+                       forall args . Fullfilled "_backward_linalg_potrf(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_linalg_potrf(symbol)" args -> IO SymbolHandle+_backward_linalg_potrf name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_potrf"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_potri(symbol)" =+     '[ '("_A", AttrOpt SymbolHandle)]++_linalg_potri ::+              forall args . Fullfilled "_linalg_potri(symbol)" args =>+                String -> ArgsHMap "_linalg_potri(symbol)" args -> IO SymbolHandle+_linalg_potri name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_potri"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_potri(symbol)" = '[]++_backward_linalg_potri ::+                       forall args . Fullfilled "_backward_linalg_potri(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_linalg_potri(symbol)" args -> IO SymbolHandle+_backward_linalg_potri name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_potri"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_trmm(symbol)" =+     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),+        '("alpha", AttrOpt Double), '("_A", AttrOpt SymbolHandle),+        '("_B", AttrOpt SymbolHandle)]++_linalg_trmm ::+             forall args . Fullfilled "_linalg_trmm(symbol)" args =>+               String -> ArgsHMap "_linalg_trmm(symbol)" args -> IO SymbolHandle+_linalg_trmm name args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),+               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_trmm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_trmm(symbol)" = '[]++_backward_linalg_trmm ::+                      forall args . Fullfilled "_backward_linalg_trmm(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_linalg_trmm(symbol)" args -> IO SymbolHandle+_backward_linalg_trmm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_trmm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_trsm(symbol)" =+     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),+        '("alpha", AttrOpt Double), '("_A", AttrOpt SymbolHandle),+        '("_B", AttrOpt SymbolHandle)]++_linalg_trsm ::+             forall args . Fullfilled "_linalg_trsm(symbol)" args =>+               String -> ArgsHMap "_linalg_trsm(symbol)" args -> IO SymbolHandle+_linalg_trsm name args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),+               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_trsm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_trsm(symbol)" = '[]++_backward_linalg_trsm ::+                      forall args . Fullfilled "_backward_linalg_trsm(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_linalg_trsm(symbol)" args -> IO SymbolHandle+_backward_linalg_trsm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_trsm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_sumlogdiag(symbol)" =+     '[ '("_A", AttrOpt SymbolHandle)]++_linalg_sumlogdiag ::+                   forall args . Fullfilled "_linalg_sumlogdiag(symbol)" args =>+                     String ->+                       ArgsHMap "_linalg_sumlogdiag(symbol)" args -> IO SymbolHandle+_linalg_sumlogdiag name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_sumlogdiag"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_sumlogdiag(symbol)" =+     '[]++_backward_linalg_sumlogdiag ::+                            forall args .+                              Fullfilled "_backward_linalg_sumlogdiag(symbol)" args =>+                              String ->+                                ArgsHMap "_backward_linalg_sumlogdiag(symbol)" args ->+                                  IO SymbolHandle+_backward_linalg_sumlogdiag name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_sumlogdiag"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_syrk(symbol)" =+     '[ '("transpose", AttrOpt Bool), '("alpha", AttrOpt Double),+        '("_A", AttrOpt SymbolHandle)]++_linalg_syrk ::+             forall args . Fullfilled "_linalg_syrk(symbol)" args =>+               String -> ArgsHMap "_linalg_syrk(symbol)" args -> IO SymbolHandle+_linalg_syrk name args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_syrk"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_syrk(symbol)" = '[]++_backward_linalg_syrk ::+                      forall args . Fullfilled "_backward_linalg_syrk(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_linalg_syrk(symbol)" args -> IO SymbolHandle+_backward_linalg_syrk name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_syrk"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_gelqf(symbol)" =+     '[ '("_A", AttrOpt SymbolHandle)]++_linalg_gelqf ::+              forall args . Fullfilled "_linalg_gelqf(symbol)" args =>+                String -> ArgsHMap "_linalg_gelqf(symbol)" args -> IO SymbolHandle+_linalg_gelqf name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gelqf"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_gelqf(symbol)" = '[]++_backward_linalg_gelqf ::+                       forall args . Fullfilled "_backward_linalg_gelqf(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_linalg_gelqf(symbol)" args -> IO SymbolHandle+_backward_linalg_gelqf name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gelqf"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_syevd(symbol)" =+     '[ '("_A", AttrOpt SymbolHandle)]++_linalg_syevd ::+              forall args . Fullfilled "_linalg_syevd(symbol)" args =>+                String -> ArgsHMap "_linalg_syevd(symbol)" args -> IO SymbolHandle+_linalg_syevd name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_syevd"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_syevd(symbol)" = '[]++_backward_linalg_syevd ::+                       forall args . Fullfilled "_backward_linalg_syevd(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_linalg_syevd(symbol)" args -> IO SymbolHandle+_backward_linalg_syevd name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_syevd"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_histogram(symbol)" =+     '[ '("bin_cnt", AttrOpt (Maybe Int)), '("range", AttrOpt Int),+        '("data", AttrOpt SymbolHandle), '("bins", AttrOpt SymbolHandle)]++_histogram ::+           forall args . Fullfilled "_histogram(symbol)" args =>+             String -> ArgsHMap "_histogram(symbol)" args -> IO SymbolHandle+_histogram name args+  = let scalarArgs+          = catMaybes+              [("bin_cnt",) . showValue <$>+                 (args !? #bin_cnt :: Maybe (Maybe Int)),+               ("range",) . showValue <$> (args !? #range :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("bins",) <$> (args !? #bins :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_histogram"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "cast_storage(symbol)" =+     '[ '("stype",+          AttrReq (EnumType '["csr", "default", "row_sparse"])),+        '("data", AttrOpt SymbolHandle)]++cast_storage ::+             forall args . Fullfilled "cast_storage(symbol)" args =>+               String -> ArgsHMap "cast_storage(symbol)" args -> IO SymbolHandle+cast_storage name args+  = let scalarArgs+          = catMaybes+              [("stype",) . showValue <$>+                 (args !? #stype ::+                    Maybe (EnumType '["csr", "default", "row_sparse"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cast_storage"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_equal_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_equal_scalar ::+              forall args . Fullfilled "_equal_scalar(symbol)" args =>+                String -> ArgsHMap "_equal_scalar(symbol)" args -> IO SymbolHandle+_equal_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_equal_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_not_equal_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_not_equal_scalar ::+                  forall args . Fullfilled "_not_equal_scalar(symbol)" args =>+                    String ->+                      ArgsHMap "_not_equal_scalar(symbol)" args -> IO SymbolHandle+_not_equal_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_not_equal_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_greater_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_greater_scalar ::+                forall args . Fullfilled "_greater_scalar(symbol)" args =>+                  String ->+                    ArgsHMap "_greater_scalar(symbol)" args -> IO SymbolHandle+_greater_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_greater_equal_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_greater_equal_scalar ::+                      forall args . Fullfilled "_greater_equal_scalar(symbol)" args =>+                        String ->+                          ArgsHMap "_greater_equal_scalar(symbol)" args -> IO SymbolHandle+_greater_equal_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_equal_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_lesser_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_lesser_scalar ::+               forall args . Fullfilled "_lesser_scalar(symbol)" args =>+                 String -> ArgsHMap "_lesser_scalar(symbol)" args -> IO SymbolHandle+_lesser_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_lesser_equal_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_lesser_equal_scalar ::+                     forall args . Fullfilled "_lesser_equal_scalar(symbol)" args =>+                       String ->+                         ArgsHMap "_lesser_equal_scalar(symbol)" args -> IO SymbolHandle+_lesser_equal_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_equal_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_logical_and_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_logical_and_scalar ::+                    forall args . Fullfilled "_logical_and_scalar(symbol)" args =>+                      String ->+                        ArgsHMap "_logical_and_scalar(symbol)" args -> IO SymbolHandle+_logical_and_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_and_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_logical_or_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_logical_or_scalar ::+                   forall args . Fullfilled "_logical_or_scalar(symbol)" args =>+                     String ->+                       ArgsHMap "_logical_or_scalar(symbol)" args -> IO SymbolHandle+_logical_or_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_or_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_logical_xor_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_logical_xor_scalar ::+                    forall args . Fullfilled "_logical_xor_scalar(symbol)" args =>+                      String ->+                        ArgsHMap "_logical_xor_scalar(symbol)" args -> IO SymbolHandle+_logical_xor_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_xor_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "relu(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++relu ::+     forall args . Fullfilled "relu(symbol)" args =>+       String -> ArgsHMap "relu(symbol)" args -> IO SymbolHandle+relu name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "relu"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_relu(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_relu ::+               forall args . Fullfilled "_backward_relu(symbol)" args =>+                 String -> ArgsHMap "_backward_relu(symbol)" args -> IO SymbolHandle+_backward_relu name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_relu"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sigmoid(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++sigmoid ::+        forall args . Fullfilled "sigmoid(symbol)" args =>+          String -> ArgsHMap "sigmoid(symbol)" args -> IO SymbolHandle+sigmoid name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sigmoid"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sigmoid(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_sigmoid ::+                  forall args . Fullfilled "_backward_sigmoid(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_sigmoid(symbol)" args -> IO SymbolHandle+_backward_sigmoid name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sigmoid"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "hard_sigmoid(symbol)" =+     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),+        '("data", AttrOpt SymbolHandle)]++hard_sigmoid ::+             forall args . Fullfilled "hard_sigmoid(symbol)" args =>+               String -> ArgsHMap "hard_sigmoid(symbol)" args -> IO SymbolHandle+hard_sigmoid name args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "hard_sigmoid"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_hard_sigmoid(symbol)" = '[]++_backward_hard_sigmoid ::+                       forall args . Fullfilled "_backward_hard_sigmoid(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_hard_sigmoid(symbol)" args -> IO SymbolHandle+_backward_hard_sigmoid name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_hard_sigmoid"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "softsign(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++softsign ::+         forall args . Fullfilled "softsign(symbol)" args =>+           String -> ArgsHMap "softsign(symbol)" args -> IO SymbolHandle+softsign name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softsign"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_softsign(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_softsign ::+                   forall args . Fullfilled "_backward_softsign(symbol)" args =>+                     String ->+                       ArgsHMap "_backward_softsign(symbol)" args -> IO SymbolHandle+_backward_softsign name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_softsign"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_copy(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++_copy ::+      forall args . Fullfilled "_copy(symbol)" args =>+        String -> ArgsHMap "_copy(symbol)" args -> IO SymbolHandle+_copy name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_copy"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_copy(symbol)" = '[]++_backward_copy ::+               forall args . Fullfilled "_backward_copy(symbol)" args =>+                 String -> ArgsHMap "_backward_copy(symbol)" args -> IO SymbolHandle+_backward_copy name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_copy"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_BlockGrad(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++_BlockGrad ::+           forall args . Fullfilled "_BlockGrad(symbol)" args =>+             String -> ArgsHMap "_BlockGrad(symbol)" args -> IO SymbolHandle+_BlockGrad name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BlockGrad"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "make_loss(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++make_loss ::+          forall args . Fullfilled "make_loss(symbol)" args =>+            String -> ArgsHMap "make_loss(symbol)" args -> IO SymbolHandle+make_loss name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "make_loss"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_identity_with_attr_like_rhs(symbol)"+     =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_identity_with_attr_like_rhs ::+                             forall args .+                               Fullfilled "_identity_with_attr_like_rhs(symbol)" args =>+                               String ->+                                 ArgsHMap "_identity_with_attr_like_rhs(symbol)" args ->+                                   IO SymbolHandle+_identity_with_attr_like_rhs name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_identity_with_attr_like_rhs"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "reshape_like(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++reshape_like ::+             forall args . Fullfilled "reshape_like(symbol)" args =>+               String -> ArgsHMap "reshape_like(symbol)" args -> IO SymbolHandle+reshape_like name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reshape_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "shape_array(symbol)" =+     '[ '("lhs_begin", AttrOpt (Maybe Int)),+        '("lhs_end", AttrOpt (Maybe Int)),+        '("rhs_begin", AttrOpt (Maybe Int)),+        '("rhs_end", AttrOpt (Maybe Int)), '("data", AttrOpt SymbolHandle)]++shape_array ::+            forall args . Fullfilled "shape_array(symbol)" args =>+              String -> ArgsHMap "shape_array(symbol)" args -> IO SymbolHandle+shape_array name args+  = let scalarArgs+          = catMaybes+              [("lhs_begin",) . showValue <$>+                 (args !? #lhs_begin :: Maybe (Maybe Int)),+               ("lhs_end",) . showValue <$>+                 (args !? #lhs_end :: Maybe (Maybe Int)),+               ("rhs_begin",) . showValue <$>+                 (args !? #rhs_begin :: Maybe (Maybe Int)),+               ("rhs_end",) . showValue <$>+                 (args !? #rhs_end :: Maybe (Maybe Int))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "shape_array"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "size_array(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++size_array ::+           forall args . Fullfilled "size_array(symbol)" args =>+             String -> ArgsHMap "size_array(symbol)" args -> IO SymbolHandle+size_array name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "size_array"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Cast(symbol)" =+     '[ '("dtype",+          AttrReq+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("data", AttrOpt SymbolHandle)]++_Cast ::+      forall args . Fullfilled "_Cast(symbol)" args =>+        String -> ArgsHMap "_Cast(symbol)" args -> IO SymbolHandle+_Cast name args+  = let scalarArgs+          = catMaybes+              [("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Cast"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_cast(symbol)" = '[]++_backward_cast ::+               forall args . Fullfilled "_backward_cast(symbol)" args =>+                 String -> ArgsHMap "_backward_cast(symbol)" args -> IO SymbolHandle+_backward_cast name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cast"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "negative(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++negative ::+         forall args . Fullfilled "negative(symbol)" args =>+           String -> ArgsHMap "negative(symbol)" args -> IO SymbolHandle+negative name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "negative"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "reciprocal(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++reciprocal ::+           forall args . Fullfilled "reciprocal(symbol)" args =>+             String -> ArgsHMap "reciprocal(symbol)" args -> IO SymbolHandle+reciprocal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reciprocal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_reciprocal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_reciprocal ::+                     forall args . Fullfilled "_backward_reciprocal(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_reciprocal(symbol)" args -> IO SymbolHandle+_backward_reciprocal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_reciprocal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "abs(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++abs ::+    forall args . Fullfilled "abs(symbol)" args =>+      String -> ArgsHMap "abs(symbol)" args -> IO SymbolHandle+abs name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "abs"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_abs(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_abs ::+              forall args . Fullfilled "_backward_abs(symbol)" args =>+                String -> ArgsHMap "_backward_abs(symbol)" args -> IO SymbolHandle+_backward_abs name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_abs"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sign(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++sign ::+     forall args . Fullfilled "sign(symbol)" args =>+       String -> ArgsHMap "sign(symbol)" args -> IO SymbolHandle+sign name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sign"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sign(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_sign ::+               forall args . Fullfilled "_backward_sign(symbol)" args =>+                 String -> ArgsHMap "_backward_sign(symbol)" args -> IO SymbolHandle+_backward_sign name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sign"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "round(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++round ::+      forall args . Fullfilled "round(symbol)" args =>+        String -> ArgsHMap "round(symbol)" args -> IO SymbolHandle+round name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "round"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "rint(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++rint ::+     forall args . Fullfilled "rint(symbol)" args =>+       String -> ArgsHMap "rint(symbol)" args -> IO SymbolHandle+rint name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rint"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "ceil(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++ceil ::+     forall args . Fullfilled "ceil(symbol)" args =>+       String -> ArgsHMap "ceil(symbol)" args -> IO SymbolHandle+ceil name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ceil"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "floor(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++floor ::+      forall args . Fullfilled "floor(symbol)" args =>+        String -> ArgsHMap "floor(symbol)" args -> IO SymbolHandle+floor name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "floor"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "trunc(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++trunc ::+      forall args . Fullfilled "trunc(symbol)" args =>+        String -> ArgsHMap "trunc(symbol)" args -> IO SymbolHandle+trunc name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "trunc"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "fix(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++fix ::+    forall args . Fullfilled "fix(symbol)" args =>+      String -> ArgsHMap "fix(symbol)" args -> IO SymbolHandle+fix name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "fix"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "square(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++square ::+       forall args . Fullfilled "square(symbol)" args =>+         String -> ArgsHMap "square(symbol)" args -> IO SymbolHandle+square name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "square"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_square(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_square ::+                 forall args . Fullfilled "_backward_square(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_square(symbol)" args -> IO SymbolHandle+_backward_square name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_square"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sqrt(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++sqrt ::+     forall args . Fullfilled "sqrt(symbol)" args =>+       String -> ArgsHMap "sqrt(symbol)" args -> IO SymbolHandle+sqrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sqrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sqrt(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_sqrt ::+               forall args . Fullfilled "_backward_sqrt(symbol)" args =>+                 String -> ArgsHMap "_backward_sqrt(symbol)" args -> IO SymbolHandle+_backward_sqrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sqrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "rsqrt(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++rsqrt ::+      forall args . Fullfilled "rsqrt(symbol)" args =>+        String -> ArgsHMap "rsqrt(symbol)" args -> IO SymbolHandle+rsqrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rsqrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_rsqrt(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_rsqrt ::+                forall args . Fullfilled "_backward_rsqrt(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_rsqrt(symbol)" args -> IO SymbolHandle+_backward_rsqrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rsqrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "cbrt(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++cbrt ::+     forall args . Fullfilled "cbrt(symbol)" args =>+       String -> ArgsHMap "cbrt(symbol)" args -> IO SymbolHandle+cbrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cbrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_cbrt(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_cbrt ::+               forall args . Fullfilled "_backward_cbrt(symbol)" args =>+                 String -> ArgsHMap "_backward_cbrt(symbol)" args -> IO SymbolHandle+_backward_cbrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cbrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "rcbrt(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++rcbrt ::+      forall args . Fullfilled "rcbrt(symbol)" args =>+        String -> ArgsHMap "rcbrt(symbol)" args -> IO SymbolHandle+rcbrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rcbrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_rcbrt(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_rcbrt ::+                forall args . Fullfilled "_backward_rcbrt(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_rcbrt(symbol)" args -> IO SymbolHandle+_backward_rcbrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rcbrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "exp(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++exp ::+    forall args . Fullfilled "exp(symbol)" args =>+      String -> ArgsHMap "exp(symbol)" args -> IO SymbolHandle+exp name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "exp"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "log(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++log ::+    forall args . Fullfilled "log(symbol)" args =>+      String -> ArgsHMap "log(symbol)" args -> IO SymbolHandle+log name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "log10(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++log10 ::+      forall args . Fullfilled "log10(symbol)" args =>+        String -> ArgsHMap "log10(symbol)" args -> IO SymbolHandle+log10 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log10"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "log2(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++log2 ::+     forall args . Fullfilled "log2(symbol)" args =>+       String -> ArgsHMap "log2(symbol)" args -> IO SymbolHandle+log2 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log2"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_log(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_log ::+              forall args . Fullfilled "_backward_log(symbol)" args =>+                String -> ArgsHMap "_backward_log(symbol)" args -> IO SymbolHandle+_backward_log name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_log10(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_log10 ::+                forall args . Fullfilled "_backward_log10(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_log10(symbol)" args -> IO SymbolHandle+_backward_log10 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log10"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_log2(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_log2 ::+               forall args . Fullfilled "_backward_log2(symbol)" args =>+                 String -> ArgsHMap "_backward_log2(symbol)" args -> IO SymbolHandle+_backward_log2 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log2"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "log1p(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++log1p ::+      forall args . Fullfilled "log1p(symbol)" args =>+        String -> ArgsHMap "log1p(symbol)" args -> IO SymbolHandle+log1p name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log1p"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_log1p(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_log1p ::+                forall args . Fullfilled "_backward_log1p(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_log1p(symbol)" args -> IO SymbolHandle+_backward_log1p name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log1p"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "expm1(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++expm1 ::+      forall args . Fullfilled "expm1(symbol)" args =>+        String -> ArgsHMap "expm1(symbol)" args -> IO SymbolHandle+expm1 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "expm1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_expm1(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_expm1 ::+                forall args . Fullfilled "_backward_expm1(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_expm1(symbol)" args -> IO SymbolHandle+_backward_expm1 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_expm1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "gamma(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++gamma ::+      forall args . Fullfilled "gamma(symbol)" args =>+        String -> ArgsHMap "gamma(symbol)" args -> IO SymbolHandle+gamma name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gamma"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_gamma(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_gamma ::+                forall args . Fullfilled "_backward_gamma(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_gamma(symbol)" args -> IO SymbolHandle+_backward_gamma name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_gamma"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "gammaln(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++gammaln ::+        forall args . Fullfilled "gammaln(symbol)" args =>+          String -> ArgsHMap "gammaln(symbol)" args -> IO SymbolHandle+gammaln name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gammaln"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_gammaln(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_gammaln ::+                  forall args . Fullfilled "_backward_gammaln(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_gammaln(symbol)" args -> IO SymbolHandle+_backward_gammaln name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_gammaln"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "logical_not(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++logical_not ::+            forall args . Fullfilled "logical_not(symbol)" args =>+              String -> ArgsHMap "logical_not(symbol)" args -> IO SymbolHandle+logical_not name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "logical_not"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sum(symbol)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++sum ::+    forall args . Fullfilled "sum(symbol)" args =>+      String -> ArgsHMap "sum(symbol)" args -> IO SymbolHandle+sum name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sum(symbol)" = '[]++_backward_sum ::+              forall args . Fullfilled "_backward_sum(symbol)" args =>+                String -> ArgsHMap "_backward_sum(symbol)" args -> IO SymbolHandle+_backward_sum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "mean(symbol)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++mean ::+     forall args . Fullfilled "mean(symbol)" args =>+       String -> ArgsHMap "mean(symbol)" args -> IO SymbolHandle+mean name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mean"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_mean(symbol)" = '[]++_backward_mean ::+               forall args . Fullfilled "_backward_mean(symbol)" args =>+                 String -> ArgsHMap "_backward_mean(symbol)" args -> IO SymbolHandle+_backward_mean name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mean"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "prod(symbol)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++prod ::+     forall args . Fullfilled "prod(symbol)" args =>+       String -> ArgsHMap "prod(symbol)" args -> IO SymbolHandle+prod name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "prod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_prod(symbol)" = '[]++_backward_prod ::+               forall args . Fullfilled "_backward_prod(symbol)" args =>+                 String -> ArgsHMap "_backward_prod(symbol)" args -> IO SymbolHandle+_backward_prod name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_prod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "nansum(symbol)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++nansum ::+       forall args . Fullfilled "nansum(symbol)" args =>+         String -> ArgsHMap "nansum(symbol)" args -> IO SymbolHandle+nansum name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "nansum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_nansum(symbol)" = '[]++_backward_nansum ::+                 forall args . Fullfilled "_backward_nansum(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_nansum(symbol)" args -> IO SymbolHandle+_backward_nansum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_nansum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "nanprod(symbol)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++nanprod ::+        forall args . Fullfilled "nanprod(symbol)" args =>+          String -> ArgsHMap "nanprod(symbol)" args -> IO SymbolHandle+nanprod name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "nanprod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_nanprod(symbol)" = '[]++_backward_nanprod ::+                  forall args . Fullfilled "_backward_nanprod(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_nanprod(symbol)" args -> IO SymbolHandle+_backward_nanprod name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_nanprod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "max(symbol)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++max ::+    forall args . Fullfilled "max(symbol)" args =>+      String -> ArgsHMap "max(symbol)" args -> IO SymbolHandle+max name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "max"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_max(symbol)" = '[]++_backward_max ::+              forall args . Fullfilled "_backward_max(symbol)" args =>+                String -> ArgsHMap "_backward_max(symbol)" args -> IO SymbolHandle+_backward_max name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_max"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "min(symbol)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++min ::+    forall args . Fullfilled "min(symbol)" args =>+      String -> ArgsHMap "min(symbol)" args -> IO SymbolHandle+min name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "min"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_min(symbol)" = '[]++_backward_min ::+              forall args . Fullfilled "_backward_min(symbol)" args =>+                String -> ArgsHMap "_backward_min(symbol)" args -> IO SymbolHandle+_backward_min name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_min"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_axis(symbol)" =+     '[ '("axis", AttrOpt [Int]), '("size", AttrOpt [Int]),+        '("data", AttrOpt SymbolHandle)]++broadcast_axis ::+               forall args . Fullfilled "broadcast_axis(symbol)" args =>+                 String -> ArgsHMap "broadcast_axis(symbol)" args -> IO SymbolHandle+broadcast_axis name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),+               ("size",) . showValue <$> (args !? #size :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_axis"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_to(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]++broadcast_to ::+             forall args . Fullfilled "broadcast_to(symbol)" args =>+               String -> ArgsHMap "broadcast_to(symbol)" args -> IO SymbolHandle+broadcast_to name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_to"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_broadcast_backward(symbol)" = '[]++_broadcast_backward ::+                    forall args . Fullfilled "_broadcast_backward(symbol)" args =>+                      String ->+                        ArgsHMap "_broadcast_backward(symbol)" args -> IO SymbolHandle+_broadcast_backward name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_broadcast_backward"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_like(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_like ::+               forall args . Fullfilled "broadcast_like(symbol)" args =>+                 String -> ArgsHMap "broadcast_like(symbol)" args -> IO SymbolHandle+broadcast_like name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "norm(symbol)" =+     '[ '("ord", AttrOpt Int), '("axis", AttrOpt (Maybe [Int])),+        '("keepdims", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++norm ::+     forall args . Fullfilled "norm(symbol)" args =>+       String -> ArgsHMap "norm(symbol)" args -> IO SymbolHandle+norm name args+  = let scalarArgs+          = catMaybes+              [("ord",) . showValue <$> (args !? #ord :: Maybe Int),+               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "norm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_norm(symbol)" = '[]++_backward_norm ::+               forall args . Fullfilled "_backward_norm(symbol)" args =>+                 String -> ArgsHMap "_backward_norm(symbol)" args -> IO SymbolHandle+_backward_norm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_norm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "elemwise_add(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++elemwise_add ::+             forall args . Fullfilled "elemwise_add(symbol)" args =>+               String -> ArgsHMap "elemwise_add(symbol)" args -> IO SymbolHandle+elemwise_add name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_add"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_grad_add(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_grad_add ::+          forall args . Fullfilled "_grad_add(symbol)" args =>+            String -> ArgsHMap "_grad_add(symbol)" args -> IO SymbolHandle+_grad_add name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_grad_add"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_add(symbol)" = '[]++_backward_add ::+              forall args . Fullfilled "_backward_add(symbol)" args =>+                String -> ArgsHMap "_backward_add(symbol)" args -> IO SymbolHandle+_backward_add name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_add"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "elemwise_sub(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++elemwise_sub ::+             forall args . Fullfilled "elemwise_sub(symbol)" args =>+               String -> ArgsHMap "elemwise_sub(symbol)" args -> IO SymbolHandle+elemwise_sub name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_sub"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sub(symbol)" = '[]++_backward_sub ::+              forall args . Fullfilled "_backward_sub(symbol)" args =>+                String -> ArgsHMap "_backward_sub(symbol)" args -> IO SymbolHandle+_backward_sub name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sub"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "elemwise_mul(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++elemwise_mul ::+             forall args . Fullfilled "elemwise_mul(symbol)" args =>+               String -> ArgsHMap "elemwise_mul(symbol)" args -> IO SymbolHandle+elemwise_mul name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_mul"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_mul(symbol)" = '[]++_backward_mul ::+              forall args . Fullfilled "_backward_mul(symbol)" args =>+                String -> ArgsHMap "_backward_mul(symbol)" args -> IO SymbolHandle+_backward_mul name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mul"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "elemwise_div(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++elemwise_div ::+             forall args . Fullfilled "elemwise_div(symbol)" args =>+               String -> ArgsHMap "elemwise_div(symbol)" args -> IO SymbolHandle+elemwise_div name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_div"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_div(symbol)" = '[]++_backward_div ::+              forall args . Fullfilled "_backward_div(symbol)" args =>+                String -> ArgsHMap "_backward_div(symbol)" args -> IO SymbolHandle+_backward_div name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_div"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_mod(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_mod ::+     forall args . Fullfilled "_mod(symbol)" args =>+       String -> ArgsHMap "_mod(symbol)" args -> IO SymbolHandle+_mod name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_mod(symbol)" = '[]++_backward_mod ::+              forall args . Fullfilled "_backward_mod(symbol)" args =>+                String -> ArgsHMap "_backward_mod(symbol)" args -> IO SymbolHandle+_backward_mod name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_scatter_elemwise_div(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_scatter_elemwise_div ::+                      forall args . Fullfilled "_scatter_elemwise_div(symbol)" args =>+                        String ->+                          ArgsHMap "_scatter_elemwise_div(symbol)" args -> IO SymbolHandle+_scatter_elemwise_div name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_elemwise_div"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_scatter_plus_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_scatter_plus_scalar ::+                     forall args . Fullfilled "_scatter_plus_scalar(symbol)" args =>+                       String ->+                         ArgsHMap "_scatter_plus_scalar(symbol)" args -> IO SymbolHandle+_scatter_plus_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_plus_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_scatter_minus_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_scatter_minus_scalar ::+                      forall args . Fullfilled "_scatter_minus_scalar(symbol)" args =>+                        String ->+                          ArgsHMap "_scatter_minus_scalar(symbol)" args -> IO SymbolHandle+_scatter_minus_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_minus_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Embedding(symbol)" =+     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("sparse_grad", AttrOpt Bool), '("data", AttrOpt SymbolHandle),+        '("weight", AttrOpt SymbolHandle)]++_Embedding ::+           forall args . Fullfilled "_Embedding(symbol)" args =>+             String -> ArgsHMap "_Embedding(symbol)" args -> IO SymbolHandle+_Embedding name args+  = let scalarArgs+          = catMaybes+              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"])),+               ("sparse_grad",) . showValue <$>+                 (args !? #sparse_grad :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Embedding"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_SparseEmbedding(symbol)" =+     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("sparse_grad", AttrOpt Bool), '("data", AttrOpt SymbolHandle),+        '("weight", AttrOpt SymbolHandle)]++_contrib_SparseEmbedding ::+                         forall args . Fullfilled "_contrib_SparseEmbedding(symbol)" args =>+                           String ->+                             ArgsHMap "_contrib_SparseEmbedding(symbol)" args -> IO SymbolHandle+_contrib_SparseEmbedding name args+  = let scalarArgs+          = catMaybes+              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"])),+               ("sparse_grad",) . showValue <$>+                 (args !? #sparse_grad :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_SparseEmbedding"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Embedding(symbol)" = '[]++_backward_Embedding ::+                    forall args . Fullfilled "_backward_Embedding(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_Embedding(symbol)" args -> IO SymbolHandle+_backward_Embedding name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Embedding"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SparseEmbedding(symbol)" =+     '[]++_backward_SparseEmbedding ::+                          forall args .+                            Fullfilled "_backward_SparseEmbedding(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_SparseEmbedding(symbol)" args ->+                                IO SymbolHandle+_backward_SparseEmbedding name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SparseEmbedding"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "take(symbol)" =+     '[ '("axis", AttrOpt Int),+        '("mode", AttrOpt (EnumType '["clip", "raise", "wrap"])),+        '("a", AttrOpt SymbolHandle), '("indices", AttrOpt SymbolHandle)]++take ::+     forall args . Fullfilled "take(symbol)" args =>+       String -> ArgsHMap "take(symbol)" args -> IO SymbolHandle+take name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("a",) <$> (args !? #a :: Maybe SymbolHandle),+               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "take"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_take(symbol)" = '[]++_backward_take ::+               forall args . Fullfilled "_backward_take(symbol)" args =>+                 String -> ArgsHMap "_backward_take(symbol)" args -> IO SymbolHandle+_backward_take name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_take"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "batch_take(symbol)" =+     '[ '("a", AttrOpt SymbolHandle),+        '("indices", AttrOpt SymbolHandle)]++batch_take ::+           forall args . Fullfilled "batch_take(symbol)" args =>+             String -> ArgsHMap "batch_take(symbol)" args -> IO SymbolHandle+batch_take name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("a",) <$> (args !? #a :: Maybe SymbolHandle),+               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "batch_take"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "one_hot(symbol)" =+     '[ '("depth", AttrReq Int), '("on_value", AttrOpt Double),+        '("off_value", AttrOpt Double),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("indices", AttrOpt SymbolHandle)]++one_hot ::+        forall args . Fullfilled "one_hot(symbol)" args =>+          String -> ArgsHMap "one_hot(symbol)" args -> IO SymbolHandle+one_hot name args+  = let scalarArgs+          = catMaybes+              [("depth",) . showValue <$> (args !? #depth :: Maybe Int),+               ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double),+               ("off_value",) . showValue <$>+                 (args !? #off_value :: Maybe Double),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "one_hot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "gather_nd(symbol)" =+     '[ '("data", AttrOpt SymbolHandle),+        '("indices", AttrOpt SymbolHandle)]++gather_nd ::+          forall args . Fullfilled "gather_nd(symbol)" args =>+            String -> ArgsHMap "gather_nd(symbol)" args -> IO SymbolHandle+gather_nd name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gather_nd"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "scatter_nd(symbol)" =+     '[ '("shape", AttrReq [Int]), '("data", AttrOpt SymbolHandle),+        '("indices", AttrOpt SymbolHandle)]++scatter_nd ::+           forall args . Fullfilled "scatter_nd(symbol)" args =>+             String -> ArgsHMap "scatter_nd(symbol)" args -> IO SymbolHandle+scatter_nd name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "scatter_nd"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_gather_nd(symbol)" =+     '[ '("shape", AttrReq [Int]), '("data", AttrOpt SymbolHandle),+        '("indices", AttrOpt SymbolHandle)]++_backward_gather_nd ::+                    forall args . Fullfilled "_backward_gather_nd(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_gather_nd(symbol)" args -> IO SymbolHandle+_backward_gather_nd name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_gather_nd"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_scatter_set_nd(symbol)" =+     '[ '("shape", AttrReq [Int]), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle), '("indices", AttrOpt SymbolHandle)]++_scatter_set_nd ::+                forall args . Fullfilled "_scatter_set_nd(symbol)" args =>+                  String ->+                    ArgsHMap "_scatter_set_nd(symbol)" args -> IO SymbolHandle+_scatter_set_nd name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle),+               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_set_nd"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_equal ::+                forall args . Fullfilled "broadcast_equal(symbol)" args =>+                  String ->+                    ArgsHMap "broadcast_equal(symbol)" args -> IO SymbolHandle+broadcast_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_not_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_not_equal ::+                    forall args . Fullfilled "broadcast_not_equal(symbol)" args =>+                      String ->+                        ArgsHMap "broadcast_not_equal(symbol)" args -> IO SymbolHandle+broadcast_not_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_not_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_greater(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_greater ::+                  forall args . Fullfilled "broadcast_greater(symbol)" args =>+                    String ->+                      ArgsHMap "broadcast_greater(symbol)" args -> IO SymbolHandle+broadcast_greater name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_greater"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_greater_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_greater_equal ::+                        forall args . Fullfilled "broadcast_greater_equal(symbol)" args =>+                          String ->+                            ArgsHMap "broadcast_greater_equal(symbol)" args -> IO SymbolHandle+broadcast_greater_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_greater_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_lesser(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_lesser ::+                 forall args . Fullfilled "broadcast_lesser(symbol)" args =>+                   String ->+                     ArgsHMap "broadcast_lesser(symbol)" args -> IO SymbolHandle+broadcast_lesser name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_lesser"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_lesser_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_lesser_equal ::+                       forall args . Fullfilled "broadcast_lesser_equal(symbol)" args =>+                         String ->+                           ArgsHMap "broadcast_lesser_equal(symbol)" args -> IO SymbolHandle+broadcast_lesser_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_lesser_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_logical_and(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_logical_and ::+                      forall args . Fullfilled "broadcast_logical_and(symbol)" args =>+                        String ->+                          ArgsHMap "broadcast_logical_and(symbol)" args -> IO SymbolHandle+broadcast_logical_and name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_logical_and"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_logical_or(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_logical_or ::+                     forall args . Fullfilled "broadcast_logical_or(symbol)" args =>+                       String ->+                         ArgsHMap "broadcast_logical_or(symbol)" args -> IO SymbolHandle+broadcast_logical_or name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_logical_or"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_logical_xor(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_logical_xor ::+                      forall args . Fullfilled "broadcast_logical_xor(symbol)" args =>+                        String ->+                          ArgsHMap "broadcast_logical_xor(symbol)" args -> IO SymbolHandle+broadcast_logical_xor name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_logical_xor"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_plus_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_plus_scalar ::+             forall args . Fullfilled "_plus_scalar(symbol)" args =>+               String -> ArgsHMap "_plus_scalar(symbol)" args -> IO SymbolHandle+_plus_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_plus_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_minus_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_minus_scalar ::+              forall args . Fullfilled "_minus_scalar(symbol)" args =>+                String -> ArgsHMap "_minus_scalar(symbol)" args -> IO SymbolHandle+_minus_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minus_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_rminus_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_rminus_scalar ::+               forall args . Fullfilled "_rminus_scalar(symbol)" args =>+                 String -> ArgsHMap "_rminus_scalar(symbol)" args -> IO SymbolHandle+_rminus_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rminus_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_mul_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_mul_scalar ::+            forall args . Fullfilled "_mul_scalar(symbol)" args =>+              String -> ArgsHMap "_mul_scalar(symbol)" args -> IO SymbolHandle+_mul_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mul_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_mul_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_backward_mul_scalar ::+                     forall args . Fullfilled "_backward_mul_scalar(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_mul_scalar(symbol)" args -> IO SymbolHandle+_backward_mul_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mul_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_div_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_div_scalar ::+            forall args . Fullfilled "_div_scalar(symbol)" args =>+              String -> ArgsHMap "_div_scalar(symbol)" args -> IO SymbolHandle+_div_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_div_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_div_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_backward_div_scalar ::+                     forall args . Fullfilled "_backward_div_scalar(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_div_scalar(symbol)" args -> IO SymbolHandle+_backward_div_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_div_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_rdiv_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_rdiv_scalar ::+             forall args . Fullfilled "_rdiv_scalar(symbol)" args =>+               String -> ArgsHMap "_rdiv_scalar(symbol)" args -> IO SymbolHandle+_rdiv_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rdiv_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_rdiv_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_rdiv_scalar ::+                      forall args . Fullfilled "_backward_rdiv_scalar(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_rdiv_scalar(symbol)" args -> IO SymbolHandle+_backward_rdiv_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rdiv_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_mod_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_mod_scalar ::+            forall args . Fullfilled "_mod_scalar(symbol)" args =>+              String -> ArgsHMap "_mod_scalar(symbol)" args -> IO SymbolHandle+_mod_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mod_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_mod_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_mod_scalar ::+                     forall args . Fullfilled "_backward_mod_scalar(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_mod_scalar(symbol)" args -> IO SymbolHandle+_backward_mod_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mod_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_rmod_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_rmod_scalar ::+             forall args . Fullfilled "_rmod_scalar(symbol)" args =>+               String -> ArgsHMap "_rmod_scalar(symbol)" args -> IO SymbolHandle+_rmod_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rmod_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_rmod_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_rmod_scalar ::+                      forall args . Fullfilled "_backward_rmod_scalar(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_rmod_scalar(symbol)" args -> IO SymbolHandle+_backward_rmod_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rmod_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_ravel_multi_index(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]++_ravel_multi_index ::+                   forall args . Fullfilled "_ravel_multi_index(symbol)" args =>+                     String ->+                       ArgsHMap "_ravel_multi_index(symbol)" args -> IO SymbolHandle+_ravel_multi_index name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_ravel_multi_index"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_unravel_index(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]++_unravel_index ::+               forall args . Fullfilled "_unravel_index(symbol)" args =>+                 String -> ArgsHMap "_unravel_index(symbol)" args -> IO SymbolHandle+_unravel_index name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_unravel_index"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "argmax(symbol)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle)]++argmax ::+       forall args . Fullfilled "argmax(symbol)" args =>+         String -> ArgsHMap "argmax(symbol)" args -> IO SymbolHandle+argmax name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmax"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "argmin(symbol)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle)]++argmin ::+       forall args . Fullfilled "argmin(symbol)" args =>+         String -> ArgsHMap "argmin(symbol)" args -> IO SymbolHandle+argmin name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmin"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "argmax_channel(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++argmax_channel ::+               forall args . Fullfilled "argmax_channel(symbol)" args =>+                 String -> ArgsHMap "argmax_channel(symbol)" args -> IO SymbolHandle+argmax_channel name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmax_channel"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "pick(symbol)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),+        '("mode", AttrOpt (EnumType '["clip", "wrap"])),+        '("data", AttrOpt SymbolHandle), '("index", AttrOpt SymbolHandle)]++pick ::+     forall args . Fullfilled "pick(symbol)" args =>+       String -> ArgsHMap "pick(symbol)" args -> IO SymbolHandle+pick name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["clip", "wrap"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("index",) <$> (args !? #index :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "pick"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_pick(symbol)" = '[]++_backward_pick ::+               forall args . Fullfilled "_backward_pick(symbol)" args =>+                 String -> ArgsHMap "_backward_pick(symbol)" args -> IO SymbolHandle+_backward_pick name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_pick"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sparse_retain(symbol)" =+     '[ '("data", AttrOpt SymbolHandle),+        '("indices", AttrOpt SymbolHandle)]++_sparse_retain ::+               forall args . Fullfilled "_sparse_retain(symbol)" args =>+                 String -> ArgsHMap "_sparse_retain(symbol)" args -> IO SymbolHandle+_sparse_retain name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sparse_retain"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sparse_retain(symbol)" = '[]++_backward_sparse_retain ::+                        forall args . Fullfilled "_backward_sparse_retain(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_sparse_retain(symbol)" args -> IO SymbolHandle+_backward_sparse_retain name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sparse_retain"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_where(symbol)" =+     '[ '("condition", AttrOpt SymbolHandle),+        '("x", AttrOpt SymbolHandle), '("y", AttrOpt SymbolHandle)]++_where ::+       forall args . Fullfilled "_where(symbol)" args =>+         String -> ArgsHMap "_where(symbol)" args -> IO SymbolHandle+_where name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("condition",) <$> (args !? #condition :: Maybe SymbolHandle),+               ("x",) <$> (args !? #x :: Maybe SymbolHandle),+               ("y",) <$> (args !? #y :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "where"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_where(symbol)" = '[]++_backward_where ::+                forall args . Fullfilled "_backward_where(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_where(symbol)" args -> IO SymbolHandle+_backward_where name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_where"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "diag(symbol)" =+     '[ '("k", AttrOpt (Maybe Int)), '("data", AttrOpt SymbolHandle)]++diag ::+     forall args . Fullfilled "diag(symbol)" args =>+       String -> ArgsHMap "diag(symbol)" args -> IO SymbolHandle+diag name args+  = let scalarArgs+          = catMaybes+              [("k",) . showValue <$> (args !? #k :: Maybe (Maybe Int))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "diag"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_diag(symbol)" = '[]++_backward_diag ::+               forall args . Fullfilled "_backward_diag(symbol)" args =>+                 String -> ArgsHMap "_backward_diag(symbol)" args -> IO SymbolHandle+_backward_diag name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_diag"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_maximum_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_maximum_scalar ::+                forall args . Fullfilled "_maximum_scalar(symbol)" args =>+                  String ->+                    ArgsHMap "_maximum_scalar(symbol)" args -> IO SymbolHandle+_maximum_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_maximum_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_maximum_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_maximum_scalar ::+                         forall args . Fullfilled "_backward_maximum_scalar(symbol)" args =>+                           String ->+                             ArgsHMap "_backward_maximum_scalar(symbol)" args -> IO SymbolHandle+_backward_maximum_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_maximum_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_minimum_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_minimum_scalar ::+                forall args . Fullfilled "_minimum_scalar(symbol)" args =>+                  String ->+                    ArgsHMap "_minimum_scalar(symbol)" args -> IO SymbolHandle+_minimum_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minimum_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_minimum_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_minimum_scalar ::+                         forall args . Fullfilled "_backward_minimum_scalar(symbol)" args =>+                           String ->+                             ArgsHMap "_backward_minimum_scalar(symbol)" args -> IO SymbolHandle+_backward_minimum_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_minimum_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_power_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_power_scalar ::+              forall args . Fullfilled "_power_scalar(symbol)" args =>+                String -> ArgsHMap "_power_scalar(symbol)" args -> IO SymbolHandle+_power_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_power_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_power_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_power_scalar ::+                       forall args . Fullfilled "_backward_power_scalar(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_power_scalar(symbol)" args -> IO SymbolHandle+_backward_power_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_power_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_rpower_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_rpower_scalar ::+               forall args . Fullfilled "_rpower_scalar(symbol)" args =>+                 String -> ArgsHMap "_rpower_scalar(symbol)" args -> IO SymbolHandle+_rpower_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rpower_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_rpower_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_rpower_scalar ::+                        forall args . Fullfilled "_backward_rpower_scalar(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_rpower_scalar(symbol)" args -> IO SymbolHandle+_backward_rpower_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rpower_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_hypot_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_hypot_scalar ::+              forall args . Fullfilled "_hypot_scalar(symbol)" args =>+                String -> ArgsHMap "_hypot_scalar(symbol)" args -> IO SymbolHandle+_hypot_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_hypot_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_hypot_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_hypot_scalar ::+                       forall args . Fullfilled "_backward_hypot_scalar(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_hypot_scalar(symbol)" args -> IO SymbolHandle+_backward_hypot_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_hypot_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "smooth_l1(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++smooth_l1 ::+          forall args . Fullfilled "smooth_l1(symbol)" args =>+            String -> ArgsHMap "smooth_l1(symbol)" args -> IO SymbolHandle+smooth_l1 name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "smooth_l1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_smooth_l1(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_smooth_l1 ::+                    forall args . Fullfilled "_backward_smooth_l1(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_smooth_l1(symbol)" args -> IO SymbolHandle+_backward_smooth_l1 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_smooth_l1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "topk(symbol)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("k", AttrOpt Int),+        '("ret_typ",+          AttrOpt (EnumType '["both", "indices", "mask", "value"])),+        '("is_ascend", AttrOpt Bool),+        '("dtype",+          AttrOpt+            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),+        '("data", AttrOpt SymbolHandle)]++topk ::+     forall args . Fullfilled "topk(symbol)" args =>+       String -> ArgsHMap "topk(symbol)" args -> IO SymbolHandle+topk name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("ret_typ",) . showValue <$>+                 (args !? #ret_typ ::+                    Maybe (EnumType '["both", "indices", "mask", "value"])),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "topk"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_topk(symbol)" = '[]++_backward_topk ::+               forall args . Fullfilled "_backward_topk(symbol)" args =>+                 String -> ArgsHMap "_backward_topk(symbol)" args -> IO SymbolHandle+_backward_topk name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_topk"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sort(symbol)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle)]++sort ::+     forall args . Fullfilled "sort(symbol)" args =>+       String -> ArgsHMap "sort(symbol)" args -> IO SymbolHandle+sort name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sort"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "argsort(symbol)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),+        '("dtype",+          AttrOpt+            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),+        '("data", AttrOpt SymbolHandle)]++argsort ::+        forall args . Fullfilled "argsort(symbol)" args =>+          String -> ArgsHMap "argsort(symbol)" args -> IO SymbolHandle+argsort name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argsort"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Reshape(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("reverse", AttrOpt Bool),+        '("target_shape", AttrOpt [Int]), '("keep_highest", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle)]++_Reshape ::+         forall args . Fullfilled "_Reshape(symbol)" args =>+           String -> ArgsHMap "_Reshape(symbol)" args -> IO SymbolHandle+_Reshape name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("keep_highest",) . showValue <$>+                 (args !? #keep_highest :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Reshape"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Flatten(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++_Flatten ::+         forall args . Fullfilled "_Flatten(symbol)" args =>+           String -> ArgsHMap "_Flatten(symbol)" args -> IO SymbolHandle+_Flatten name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Flatten"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "transpose(symbol)" =+     '[ '("axes", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]++transpose ::+          forall args . Fullfilled "transpose(symbol)" args =>+            String -> ArgsHMap "transpose(symbol)" args -> IO SymbolHandle+transpose name args+  = let scalarArgs+          = catMaybes+              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "transpose"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "expand_dims(symbol)" =+     '[ '("axis", AttrReq Int), '("data", AttrOpt SymbolHandle)]++expand_dims ::+            forall args . Fullfilled "expand_dims(symbol)" args =>+              String -> ArgsHMap "expand_dims(symbol)" args -> IO SymbolHandle+expand_dims name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "expand_dims"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "slice(symbol)" =+     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),+        '("step", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]++slice ::+      forall args . Fullfilled "slice(symbol)" args =>+        String -> ArgsHMap "slice(symbol)" args -> IO SymbolHandle+slice name args+  = let scalarArgs+          = catMaybes+              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "slice"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_slice(symbol)" = '[]++_backward_slice ::+                forall args . Fullfilled "_backward_slice(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_slice(symbol)" args -> IO SymbolHandle+_backward_slice name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_slice"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_slice_assign(symbol)" =+     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),+        '("step", AttrOpt [Int]), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_slice_assign ::+              forall args . Fullfilled "_slice_assign(symbol)" args =>+                String -> ArgsHMap "_slice_assign(symbol)" args -> IO SymbolHandle+_slice_assign name args+  = let scalarArgs+          = catMaybes+              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_slice_assign"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_slice_assign_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("begin", AttrReq [Int]),+        '("end", AttrReq [Int]), '("step", AttrOpt [Int]),+        '("data", AttrOpt SymbolHandle)]++_slice_assign_scalar ::+                     forall args . Fullfilled "_slice_assign_scalar(symbol)" args =>+                       String ->+                         ArgsHMap "_slice_assign_scalar(symbol)" args -> IO SymbolHandle+_slice_assign_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float),+               ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_slice_assign_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "slice_axis(symbol)" =+     '[ '("axis", AttrReq Int), '("begin", AttrReq Int),+        '("end", AttrReq (Maybe Int)), '("data", AttrOpt SymbolHandle)]++slice_axis ::+           forall args . Fullfilled "slice_axis(symbol)" args =>+             String -> ArgsHMap "slice_axis(symbol)" args -> IO SymbolHandle+slice_axis name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("begin",) . showValue <$> (args !? #begin :: Maybe Int),+               ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "slice_axis"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_slice_axis(symbol)" = '[]++_backward_slice_axis ::+                     forall args . Fullfilled "_backward_slice_axis(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_slice_axis(symbol)" args -> IO SymbolHandle+_backward_slice_axis name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_slice_axis"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "slice_like(symbol)" =+     '[ '("axes", AttrOpt [Int]), '("data", AttrOpt SymbolHandle),+        '("shape_like", AttrOpt SymbolHandle)]++slice_like ::+           forall args . Fullfilled "slice_like(symbol)" args =>+             String -> ArgsHMap "slice_like(symbol)" args -> IO SymbolHandle+slice_like name args+  = let scalarArgs+          = catMaybes+              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("shape_like",) <$> (args !? #shape_like :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "slice_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_slice_like(symbol)" = '[]++_backward_slice_like ::+                     forall args . Fullfilled "_backward_slice_like(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_slice_like(symbol)" args -> IO SymbolHandle+_backward_slice_like name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_slice_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "clip(symbol)" =+     '[ '("a_min", AttrReq Float), '("a_max", AttrReq Float),+        '("data", AttrOpt SymbolHandle)]++clip ::+     forall args . Fullfilled "clip(symbol)" args =>+       String -> ArgsHMap "clip(symbol)" args -> IO SymbolHandle+clip name args+  = let scalarArgs+          = catMaybes+              [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float),+               ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "clip"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_clip(symbol)" = '[]++_backward_clip ::+               forall args . Fullfilled "_backward_clip(symbol)" args =>+                 String -> ArgsHMap "_backward_clip(symbol)" args -> IO SymbolHandle+_backward_clip name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_clip"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "repeat(symbol)" =+     '[ '("repeats", AttrReq Int), '("axis", AttrOpt (Maybe Int)),+        '("data", AttrOpt SymbolHandle)]++repeat ::+       forall args . Fullfilled "repeat(symbol)" args =>+         String -> ArgsHMap "repeat(symbol)" args -> IO SymbolHandle+repeat name args+  = let scalarArgs+          = catMaybes+              [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int),+               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "repeat"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_repeat(symbol)" = '[]++_backward_repeat ::+                 forall args . Fullfilled "_backward_repeat(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_repeat(symbol)" args -> IO SymbolHandle+_backward_repeat name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_repeat"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "tile(symbol)" =+     '[ '("reps", AttrReq [Int]), '("data", AttrOpt SymbolHandle)]++tile ::+     forall args . Fullfilled "tile(symbol)" args =>+       String -> ArgsHMap "tile(symbol)" args -> IO SymbolHandle+tile name args+  = let scalarArgs+          = catMaybes+              [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tile"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_tile(symbol)" = '[]++_backward_tile ::+               forall args . Fullfilled "_backward_tile(symbol)" args =>+                 String -> ArgsHMap "_backward_tile(symbol)" args -> IO SymbolHandle+_backward_tile name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tile"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "reverse(symbol)" =+     '[ '("axis", AttrReq [Int]), '("data", AttrOpt SymbolHandle)]++reverse ::+        forall args . Fullfilled "reverse(symbol)" args =>+          String -> ArgsHMap "reverse(symbol)" args -> IO SymbolHandle+reverse name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reverse"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_reverse(symbol)" = '[]++_backward_reverse ::+                  forall args . Fullfilled "_backward_reverse(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_reverse(symbol)" args -> IO SymbolHandle+_backward_reverse name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_reverse"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "stack(symbol)" =+     '[ '("axis", AttrOpt Int), '("num_args", AttrReq Int),+        '("data", AttrOpt [SymbolHandle])]++stack ::+      forall args . Fullfilled "stack(symbol)" args =>+        String -> ArgsHMap "stack(symbol)" args -> IO SymbolHandle+stack name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "stack"+         sym <- if hasKey args #num_args then+                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals+                  else+                  mxSymbolCreateAtomicSymbol (fromOpHandle op)+                    ("num_args" : scalarkeys)+                    (showValue (length array) : scalarvals)+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_backward_stack(symbol)" = '[]++_backward_stack ::+                forall args . Fullfilled "_backward_stack(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_stack(symbol)" args -> IO SymbolHandle+_backward_stack name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_stack"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "squeeze(symbol)" =+     '[ '("axis", AttrOpt (Maybe [Int])),+        '("data", AttrOpt [SymbolHandle])]++squeeze ::+        forall args . Fullfilled "squeeze(symbol)" args =>+          String -> ArgsHMap "squeeze(symbol)" args -> IO SymbolHandle+squeeze name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "squeeze"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_backward_squeeze(symbol)" = '[]++_backward_squeeze ::+                  forall args . Fullfilled "_backward_squeeze(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_squeeze(symbol)" args -> IO SymbolHandle+_backward_squeeze name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_squeeze"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "depth_to_space(symbol)" =+     '[ '("block_size", AttrReq Int), '("data", AttrOpt SymbolHandle)]++depth_to_space ::+               forall args . Fullfilled "depth_to_space(symbol)" args =>+                 String -> ArgsHMap "depth_to_space(symbol)" args -> IO SymbolHandle+depth_to_space name args+  = let scalarArgs+          = catMaybes+              [("block_size",) . showValue <$>+                 (args !? #block_size :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "depth_to_space"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "space_to_depth(symbol)" =+     '[ '("block_size", AttrReq Int), '("data", AttrOpt SymbolHandle)]++space_to_depth ::+               forall args . Fullfilled "space_to_depth(symbol)" args =>+                 String -> ArgsHMap "space_to_depth(symbol)" args -> IO SymbolHandle+space_to_depth name args+  = let scalarArgs+          = catMaybes+              [("block_size",) . showValue <$>+                 (args !? #block_size :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "space_to_depth"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "dot(symbol)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("forward_stype",+          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))),+        '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++dot ::+    forall args . Fullfilled "dot(symbol)" args =>+      String -> ArgsHMap "dot(symbol)" args -> IO SymbolHandle+dot name args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("forward_stype",) . showValue <$>+                 (args !? #forward_stype ::+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "dot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_dot(symbol)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("forward_stype",+          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"])))]++_backward_dot ::+              forall args . Fullfilled "_backward_dot(symbol)" args =>+                String -> ArgsHMap "_backward_dot(symbol)" args -> IO SymbolHandle+_backward_dot name args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("forward_stype",) . showValue <$>+                 (args !? #forward_stype ::+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_dot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "batch_dot(symbol)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("forward_stype",+          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))),+        '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++batch_dot ::+          forall args . Fullfilled "batch_dot(symbol)" args =>+            String -> ArgsHMap "batch_dot(symbol)" args -> IO SymbolHandle+batch_dot name args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("forward_stype",) . showValue <$>+                 (args !? #forward_stype ::+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "batch_dot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_batch_dot(symbol)" = '[]++_backward_batch_dot ::+                    forall args . Fullfilled "_backward_batch_dot(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_batch_dot(symbol)" args -> IO SymbolHandle+_backward_batch_dot name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_batch_dot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sin(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++sin ::+    forall args . Fullfilled "sin(symbol)" args =>+      String -> ArgsHMap "sin(symbol)" args -> IO SymbolHandle+sin name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sin"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sin(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_sin ::+              forall args . Fullfilled "_backward_sin(symbol)" args =>+                String -> ArgsHMap "_backward_sin(symbol)" args -> IO SymbolHandle+_backward_sin name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sin"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "cos(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++cos ::+    forall args . Fullfilled "cos(symbol)" args =>+      String -> ArgsHMap "cos(symbol)" args -> IO SymbolHandle+cos name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cos"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_cos(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_cos ::+              forall args . Fullfilled "_backward_cos(symbol)" args =>+                String -> ArgsHMap "_backward_cos(symbol)" args -> IO SymbolHandle+_backward_cos name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cos"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "tan(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++tan ::+    forall args . Fullfilled "tan(symbol)" args =>+      String -> ArgsHMap "tan(symbol)" args -> IO SymbolHandle+tan name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tan"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_tan(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_tan ::+              forall args . Fullfilled "_backward_tan(symbol)" args =>+                String -> ArgsHMap "_backward_tan(symbol)" args -> IO SymbolHandle+_backward_tan name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tan"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "arcsin(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++arcsin ::+       forall args . Fullfilled "arcsin(symbol)" args =>+         String -> ArgsHMap "arcsin(symbol)" args -> IO SymbolHandle+arcsin name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arcsin"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_arcsin(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_arcsin ::+                 forall args . Fullfilled "_backward_arcsin(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_arcsin(symbol)" args -> IO SymbolHandle+_backward_arcsin name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arcsin"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "arccos(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++arccos ::+       forall args . Fullfilled "arccos(symbol)" args =>+         String -> ArgsHMap "arccos(symbol)" args -> IO SymbolHandle+arccos name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arccos"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_arccos(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_arccos ::+                 forall args . Fullfilled "_backward_arccos(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_arccos(symbol)" args -> IO SymbolHandle+_backward_arccos name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arccos"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "arctan(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++arctan ::+       forall args . Fullfilled "arctan(symbol)" args =>+         String -> ArgsHMap "arctan(symbol)" args -> IO SymbolHandle+arctan name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arctan"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_arctan(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_arctan ::+                 forall args . Fullfilled "_backward_arctan(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_arctan(symbol)" args -> IO SymbolHandle+_backward_arctan name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arctan"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "degrees(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++degrees ::+        forall args . Fullfilled "degrees(symbol)" args =>+          String -> ArgsHMap "degrees(symbol)" args -> IO SymbolHandle+degrees name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "degrees"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_degrees(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_degrees ::+                  forall args . Fullfilled "_backward_degrees(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_degrees(symbol)" args -> IO SymbolHandle+_backward_degrees name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_degrees"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "radians(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++radians ::+        forall args . Fullfilled "radians(symbol)" args =>+          String -> ArgsHMap "radians(symbol)" args -> IO SymbolHandle+radians name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "radians"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_radians(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_radians ::+                  forall args . Fullfilled "_backward_radians(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_radians(symbol)" args -> IO SymbolHandle+_backward_radians name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_radians"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sinh(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++sinh ::+     forall args . Fullfilled "sinh(symbol)" args =>+       String -> ArgsHMap "sinh(symbol)" args -> IO SymbolHandle+sinh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sinh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sinh(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_sinh ::+               forall args . Fullfilled "_backward_sinh(symbol)" args =>+                 String -> ArgsHMap "_backward_sinh(symbol)" args -> IO SymbolHandle+_backward_sinh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sinh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "cosh(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++cosh ::+     forall args . Fullfilled "cosh(symbol)" args =>+       String -> ArgsHMap "cosh(symbol)" args -> IO SymbolHandle+cosh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cosh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_cosh(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_cosh ::+               forall args . Fullfilled "_backward_cosh(symbol)" args =>+                 String -> ArgsHMap "_backward_cosh(symbol)" args -> IO SymbolHandle+_backward_cosh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cosh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "tanh(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++tanh ::+     forall args . Fullfilled "tanh(symbol)" args =>+       String -> ArgsHMap "tanh(symbol)" args -> IO SymbolHandle+tanh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tanh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_tanh(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_tanh ::+               forall args . Fullfilled "_backward_tanh(symbol)" args =>+                 String -> ArgsHMap "_backward_tanh(symbol)" args -> IO SymbolHandle+_backward_tanh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tanh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "arcsinh(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++arcsinh ::+        forall args . Fullfilled "arcsinh(symbol)" args =>+          String -> ArgsHMap "arcsinh(symbol)" args -> IO SymbolHandle+arcsinh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arcsinh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_arcsinh(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_arcsinh ::+                  forall args . Fullfilled "_backward_arcsinh(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_arcsinh(symbol)" args -> IO SymbolHandle+_backward_arcsinh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arcsinh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "arccosh(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++arccosh ::+        forall args . Fullfilled "arccosh(symbol)" args =>+          String -> ArgsHMap "arccosh(symbol)" args -> IO SymbolHandle+arccosh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arccosh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_arccosh(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_arccosh ::+                  forall args . Fullfilled "_backward_arccosh(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_arccosh(symbol)" args -> IO SymbolHandle+_backward_arccosh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arccosh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "arctanh(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++arctanh ::+        forall args . Fullfilled "arctanh(symbol)" args =>+          String -> ArgsHMap "arctanh(symbol)" args -> IO SymbolHandle+arctanh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arctanh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_arctanh(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_arctanh ::+                  forall args . Fullfilled "_backward_arctanh(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_arctanh(symbol)" args -> IO SymbolHandle+_backward_arctanh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arctanh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_CTCLoss(symbol)" =+     '[ '("use_data_lengths", AttrOpt Bool),+        '("use_label_lengths", AttrOpt Bool),+        '("blank_label", AttrOpt (EnumType '["first", "last"])),+        '("data", AttrOpt SymbolHandle), '("label", AttrOpt SymbolHandle),+        '("data_lengths", AttrOpt SymbolHandle),+        '("label_lengths", AttrOpt SymbolHandle)]++_contrib_CTCLoss ::+                 forall args . Fullfilled "_contrib_CTCLoss(symbol)" args =>+                   String ->+                     ArgsHMap "_contrib_CTCLoss(symbol)" args -> IO SymbolHandle+_contrib_CTCLoss name args+  = let scalarArgs+          = catMaybes+              [("use_data_lengths",) . showValue <$>+                 (args !? #use_data_lengths :: Maybe Bool),+               ("use_label_lengths",) . showValue <$>+                 (args !? #use_label_lengths :: Maybe Bool),+               ("blank_label",) . showValue <$>+                 (args !? #blank_label :: Maybe (EnumType '["first", "last"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle),+               ("data_lengths",) <$>+                 (args !? #data_lengths :: Maybe SymbolHandle),+               ("label_lengths",) <$>+                 (args !? #label_lengths :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_CTCLoss"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_quadratic(symbol)" =+     '[ '("a", AttrOpt Float), '("b", AttrOpt Float),+        '("c", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_contrib_quadratic ::+                   forall args . Fullfilled "_contrib_quadratic(symbol)" args =>+                     String ->+                       ArgsHMap "_contrib_quadratic(symbol)" args -> IO SymbolHandle+_contrib_quadratic name args+  = let scalarArgs+          = catMaybes+              [("a",) . showValue <$> (args !? #a :: Maybe Float),+               ("b",) . showValue <$> (args !? #b :: Maybe Float),+               ("c",) . showValue <$> (args !? #c :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quadratic"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_backward_quadratic(symbol)" =+     '[]++_contrib_backward_quadratic ::+                            forall args .+                              Fullfilled "_contrib_backward_quadratic(symbol)" args =>+                              String ->+                                ArgsHMap "_contrib_backward_quadratic(symbol)" args ->+                                  IO SymbolHandle+_contrib_backward_quadratic name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_backward_quadratic"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_div_sqrt_dim(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++_contrib_div_sqrt_dim ::+                      forall args . Fullfilled "_contrib_div_sqrt_dim(symbol)" args =>+                        String ->+                          ArgsHMap "_contrib_div_sqrt_dim(symbol)" args -> IO SymbolHandle+_contrib_div_sqrt_dim name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_div_sqrt_dim"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "khatri_rao(symbol)" =+     '[ '("args", AttrOpt [SymbolHandle])]++khatri_rao ::+           forall args . Fullfilled "khatri_rao(symbol)" args =>+             String -> ArgsHMap "khatri_rao(symbol)" args -> IO SymbolHandle+khatri_rao name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "khatri_rao"+         sym <- if hasKey args #num_args then+                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals+                  else+                  mxSymbolCreateAtomicSymbol (fromOpHandle op)+                    ("num_args" : scalarkeys)+                    (showValue (length array) : scalarvals)+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_contrib_ROIAlign(symbol)" =+     '[ '("pooled_size", AttrReq [Int]),+        '("spatial_scale", AttrReq Float), '("sample_ratio", AttrOpt Int),+        '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle)]++_contrib_ROIAlign ::+                  forall args . Fullfilled "_contrib_ROIAlign(symbol)" args =>+                    String ->+                      ArgsHMap "_contrib_ROIAlign(symbol)" args -> IO SymbolHandle+_contrib_ROIAlign name args+  = let scalarArgs+          = catMaybes+              [("pooled_size",) . showValue <$>+                 (args !? #pooled_size :: Maybe [Int]),+               ("spatial_scale",) . showValue <$>+                 (args !? #spatial_scale :: Maybe Float),+               ("sample_ratio",) . showValue <$>+                 (args !? #sample_ratio :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_ROIAlign"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_ROIAlign(symbol)" = '[]++_backward_ROIAlign ::+                   forall args . Fullfilled "_backward_ROIAlign(symbol)" args =>+                     String ->+                       ArgsHMap "_backward_ROIAlign(symbol)" args -> IO SymbolHandle+_backward_ROIAlign name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_ROIAlign"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_box_nms(symbol)" =+     '[ '("overlap_thresh", AttrOpt Float),+        '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int),+        '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int),+        '("id_index", AttrOpt Int), '("force_suppress", AttrOpt Bool),+        '("in_format", AttrOpt (EnumType '["center", "corner"])),+        '("out_format", AttrOpt (EnumType '["center", "corner"])),+        '("data", AttrOpt SymbolHandle)]++_contrib_box_nms ::+                 forall args . Fullfilled "_contrib_box_nms(symbol)" args =>+                   String ->+                     ArgsHMap "_contrib_box_nms(symbol)" args -> IO SymbolHandle+_contrib_box_nms name args+  = let scalarArgs+          = catMaybes+              [("overlap_thresh",) . showValue <$>+                 (args !? #overlap_thresh :: Maybe Float),+               ("valid_thresh",) . showValue <$>+                 (args !? #valid_thresh :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),+               ("coord_start",) . showValue <$>+                 (args !? #coord_start :: Maybe Int),+               ("score_index",) . showValue <$>+                 (args !? #score_index :: Maybe Int),+               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),+               ("force_suppress",) . showValue <$>+                 (args !? #force_suppress :: Maybe Bool),+               ("in_format",) . showValue <$>+                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),+               ("out_format",) . showValue <$>+                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_box_nms"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_contrib_box_nms(symbol)" =+     '[ '("overlap_thresh", AttrOpt Float),+        '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int),+        '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int),+        '("id_index", AttrOpt Int), '("force_suppress", AttrOpt Bool),+        '("in_format", AttrOpt (EnumType '["center", "corner"])),+        '("out_format", AttrOpt (EnumType '["center", "corner"]))]++_backward_contrib_box_nms ::+                          forall args .+                            Fullfilled "_backward_contrib_box_nms(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_contrib_box_nms(symbol)" args ->+                                IO SymbolHandle+_backward_contrib_box_nms name args+  = let scalarArgs+          = catMaybes+              [("overlap_thresh",) . showValue <$>+                 (args !? #overlap_thresh :: Maybe Float),+               ("valid_thresh",) . showValue <$>+                 (args !? #valid_thresh :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),+               ("coord_start",) . showValue <$>+                 (args !? #coord_start :: Maybe Int),+               ("score_index",) . showValue <$>+                 (args !? #score_index :: Maybe Int),+               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),+               ("force_suppress",) . showValue <$>+                 (args !? #force_suppress :: Maybe Bool),+               ("in_format",) . showValue <$>+                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),+               ("out_format",) . showValue <$>+                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_box_nms"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_box_iou(symbol)" =+     '[ '("format", AttrOpt (EnumType '["center", "corner"])),+        '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_contrib_box_iou ::+                 forall args . Fullfilled "_contrib_box_iou(symbol)" args =>+                   String ->+                     ArgsHMap "_contrib_box_iou(symbol)" args -> IO SymbolHandle+_contrib_box_iou name args+  = let scalarArgs+          = catMaybes+              [("format",) . showValue <$>+                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_box_iou"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_contrib_box_iou(symbol)" =+     '[ '("format", AttrOpt (EnumType '["center", "corner"]))]++_backward_contrib_box_iou ::+                          forall args .+                            Fullfilled "_backward_contrib_box_iou(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_contrib_box_iou(symbol)" args ->+                                IO SymbolHandle+_backward_contrib_box_iou name args+  = let scalarArgs+          = catMaybes+              [("format",) . showValue <$>+                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_box_iou"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_bipartite_matching(symbol)" =+     '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float),+        '("topk", AttrOpt Int), '("data", AttrOpt SymbolHandle)]++_contrib_bipartite_matching ::+                            forall args .+                              Fullfilled "_contrib_bipartite_matching(symbol)" args =>+                              String ->+                                ArgsHMap "_contrib_bipartite_matching(symbol)" args ->+                                  IO SymbolHandle+_contrib_bipartite_matching name args+  = let scalarArgs+          = catMaybes+              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_bipartite_matching"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward_contrib_bipartite_matching(symbol)" =+     '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float),+        '("topk", AttrOpt Int)]++_backward_contrib_bipartite_matching ::+                                     forall args .+                                       Fullfilled "_backward_contrib_bipartite_matching(symbol)"+                                         args =>+                                       String ->+                                         ArgsHMap "_backward_contrib_bipartite_matching(symbol)"+                                           args+                                           -> IO SymbolHandle+_backward_contrib_bipartite_matching name args+  = let scalarArgs+          = catMaybes+              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_bipartite_matching"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_BilinearResize2D(symbol)" =+     '[ '("height", AttrReq Int), '("width", AttrReq Int),+        '("data", AttrOpt SymbolHandle)]++_contrib_BilinearResize2D ::+                          forall args .+                            Fullfilled "_contrib_BilinearResize2D(symbol)" args =>+                            String ->+                              ArgsHMap "_contrib_BilinearResize2D(symbol)" args ->+                                IO SymbolHandle+_contrib_BilinearResize2D name args+  = let scalarArgs+          = catMaybes+              [("height",) . showValue <$> (args !? #height :: Maybe Int),+               ("width",) . showValue <$> (args !? #width :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_BilinearResize2D"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward_contrib_BilinearResize2D(symbol)" = '[]++_backward_contrib_BilinearResize2D ::+                                   forall args .+                                     Fullfilled "_backward_contrib_BilinearResize2D(symbol)" args =>+                                     String ->+                                       ArgsHMap "_backward_contrib_BilinearResize2D(symbol)" args ->+                                         IO SymbolHandle+_backward_contrib_BilinearResize2D name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_BilinearResize2D"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_SyncBatchNorm(symbol)" =+     '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float),+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),+        '("output_mean_var", AttrOpt Bool), '("ndev", AttrOpt Int),+        '("key", AttrOpt String), '("data", AttrOpt SymbolHandle),+        '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle),+        '("moving_mean", AttrOpt SymbolHandle),+        '("moving_var", AttrOpt SymbolHandle)]++_contrib_SyncBatchNorm ::+                       forall args . Fullfilled "_contrib_SyncBatchNorm(symbol)" args =>+                         String ->+                           ArgsHMap "_contrib_SyncBatchNorm(symbol)" args -> IO SymbolHandle+_contrib_SyncBatchNorm name args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool),+               ("ndev",) . showValue <$> (args !? #ndev :: Maybe Int),+               ("key",) . showValue <$> (args !? #key :: Maybe String)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),+               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle),+               ("moving_mean",) <$> (args !? #moving_mean :: Maybe SymbolHandle),+               ("moving_var",) <$> (args !? #moving_var :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_SyncBatchNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_AdaptiveAvgPooling2D(symbol)"+     =+     '[ '("output_size", AttrOpt [Int]),+        '("data", AttrOpt SymbolHandle)]++_contrib_AdaptiveAvgPooling2D ::+                              forall args .+                                Fullfilled "_contrib_AdaptiveAvgPooling2D(symbol)" args =>+                                String ->+                                  ArgsHMap "_contrib_AdaptiveAvgPooling2D(symbol)" args ->+                                    IO SymbolHandle+_contrib_AdaptiveAvgPooling2D name args+  = let scalarArgs+          = catMaybes+              [("output_size",) . showValue <$>+                 (args !? #output_size :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_AdaptiveAvgPooling2D"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward_contrib_AdaptiveAvgPooling2D(symbol)" =+     '[]++_backward_contrib_AdaptiveAvgPooling2D ::+                                       forall args .+                                         Fullfilled "_backward_contrib_AdaptiveAvgPooling2D(symbol)"+                                           args =>+                                         String ->+                                           ArgsHMap "_backward_contrib_AdaptiveAvgPooling2D(symbol)"+                                             args+                                             -> IO SymbolHandle+_backward_contrib_AdaptiveAvgPooling2D name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_AdaptiveAvgPooling2D"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_to_tensor(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++_image_to_tensor ::+                 forall args . Fullfilled "_image_to_tensor(symbol)" args =>+                   String ->+                     ArgsHMap "_image_to_tensor(symbol)" args -> IO SymbolHandle+_image_to_tensor name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_to_tensor"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_normalize(symbol)" =+     '[ '("mean", AttrReq [Float]), '("std", AttrReq [Float]),+        '("data", AttrOpt SymbolHandle)]++_image_normalize ::+                 forall args . Fullfilled "_image_normalize(symbol)" args =>+                   String ->+                     ArgsHMap "_image_normalize(symbol)" args -> IO SymbolHandle+_image_normalize name args+  = let scalarArgs+          = catMaybes+              [("mean",) . showValue <$> (args !? #mean :: Maybe [Float]),+               ("std",) . showValue <$> (args !? #std :: Maybe [Float])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_normalize"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_flip_left_right(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++_image_flip_left_right ::+                       forall args . Fullfilled "_image_flip_left_right(symbol)" args =>+                         String ->+                           ArgsHMap "_image_flip_left_right(symbol)" args -> IO SymbolHandle+_image_flip_left_right name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_flip_left_right"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_random_flip_left_right(symbol)"+     = '[ '("data", AttrOpt SymbolHandle)]++_image_random_flip_left_right ::+                              forall args .+                                Fullfilled "_image_random_flip_left_right(symbol)" args =>+                                String ->+                                  ArgsHMap "_image_random_flip_left_right(symbol)" args ->+                                    IO SymbolHandle+_image_random_flip_left_right name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_flip_left_right"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_flip_top_bottom(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++_image_flip_top_bottom ::+                       forall args . Fullfilled "_image_flip_top_bottom(symbol)" args =>+                         String ->+                           ArgsHMap "_image_flip_top_bottom(symbol)" args -> IO SymbolHandle+_image_flip_top_bottom name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_flip_top_bottom"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_random_flip_top_bottom(symbol)"+     = '[ '("data", AttrOpt SymbolHandle)]++_image_random_flip_top_bottom ::+                              forall args .+                                Fullfilled "_image_random_flip_top_bottom(symbol)" args =>+                                String ->+                                  ArgsHMap "_image_random_flip_top_bottom(symbol)" args ->+                                    IO SymbolHandle+_image_random_flip_top_bottom name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_flip_top_bottom"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_random_brightness(symbol)" =+     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),+        '("data", AttrOpt SymbolHandle)]++_image_random_brightness ::+                         forall args . Fullfilled "_image_random_brightness(symbol)" args =>+                           String ->+                             ArgsHMap "_image_random_brightness(symbol)" args -> IO SymbolHandle+_image_random_brightness name args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_brightness"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_random_contrast(symbol)" =+     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),+        '("data", AttrOpt SymbolHandle)]++_image_random_contrast ::+                       forall args . Fullfilled "_image_random_contrast(symbol)" args =>+                         String ->+                           ArgsHMap "_image_random_contrast(symbol)" args -> IO SymbolHandle+_image_random_contrast name args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_contrast"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_random_saturation(symbol)" =+     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),+        '("data", AttrOpt SymbolHandle)]++_image_random_saturation ::+                         forall args . Fullfilled "_image_random_saturation(symbol)" args =>+                           String ->+                             ArgsHMap "_image_random_saturation(symbol)" args -> IO SymbolHandle+_image_random_saturation name args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_saturation"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_random_hue(symbol)" =+     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),+        '("data", AttrOpt SymbolHandle)]++_image_random_hue ::+                  forall args . Fullfilled "_image_random_hue(symbol)" args =>+                    String ->+                      ArgsHMap "_image_random_hue(symbol)" args -> IO SymbolHandle+_image_random_hue name args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_hue"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_random_color_jitter(symbol)" =+     '[ '("brightness", AttrReq Float), '("contrast", AttrReq Float),+        '("saturation", AttrReq Float), '("hue", AttrReq Float),+        '("data", AttrOpt SymbolHandle)]++_image_random_color_jitter ::+                           forall args .+                             Fullfilled "_image_random_color_jitter(symbol)" args =>+                             String ->+                               ArgsHMap "_image_random_color_jitter(symbol)" args ->+                                 IO SymbolHandle+_image_random_color_jitter name args+  = let scalarArgs+          = catMaybes+              [("brightness",) . showValue <$>+                 (args !? #brightness :: Maybe Float),+               ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float),+               ("saturation",) . showValue <$>+                 (args !? #saturation :: Maybe Float),+               ("hue",) . showValue <$> (args !? #hue :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_color_jitter"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_adjust_lighting(symbol)" =+     '[ '("alpha", AttrReq [Float]), '("data", AttrOpt SymbolHandle)]++_image_adjust_lighting ::+                       forall args . Fullfilled "_image_adjust_lighting(symbol)" args =>+                         String ->+                           ArgsHMap "_image_adjust_lighting(symbol)" args -> IO SymbolHandle+_image_adjust_lighting name args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe [Float])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_adjust_lighting"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_random_lighting(symbol)" =+     '[ '("alpha_std", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_image_random_lighting ::+                       forall args . Fullfilled "_image_random_lighting(symbol)" args =>+                         String ->+                           ArgsHMap "_image_random_lighting(symbol)" args -> IO SymbolHandle+_image_random_lighting name args+  = let scalarArgs+          = catMaybes+              [("alpha_std",) . showValue <$>+                 (args !? #alpha_std :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_lighting"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "softmax(symbol)" =+     '[ '("axis", AttrOpt Int),+        '("temperature", AttrOpt (Maybe Double)),+        '("data", AttrOpt SymbolHandle)]++softmax ::+        forall args . Fullfilled "softmax(symbol)" args =>+          String -> ArgsHMap "softmax(symbol)" args -> IO SymbolHandle+softmax name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("temperature",) . showValue <$>+                 (args !? #temperature :: Maybe (Maybe Double))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softmax"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_softmax(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_softmax ::+                  forall args . Fullfilled "_backward_softmax(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_softmax(symbol)" args -> IO SymbolHandle+_backward_softmax name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_softmax"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "log_softmax(symbol)" =+     '[ '("axis", AttrOpt Int),+        '("temperature", AttrOpt (Maybe Double)),+        '("data", AttrOpt SymbolHandle)]++log_softmax ::+            forall args . Fullfilled "log_softmax(symbol)" args =>+              String -> ArgsHMap "log_softmax(symbol)" args -> IO SymbolHandle+log_softmax name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("temperature",) . showValue <$>+                 (args !? #temperature :: Maybe (Maybe Double))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log_softmax"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_log_softmax(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_log_softmax ::+                      forall args . Fullfilled "_backward_log_softmax(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_log_softmax(symbol)" args -> IO SymbolHandle+_backward_log_softmax name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log_softmax"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Pooling(symbol)" =+     '[ '("kernel", AttrOpt [Int]),+        '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])),+        '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool),+        '("pooling_convention", AttrOpt (EnumType '["full", "valid"])),+        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("p_value", AttrOpt (Maybe Int)),+        '("count_include_pad", AttrOpt (Maybe Bool)),+        '("data", AttrOpt SymbolHandle)]++_Pooling ::+         forall args . Fullfilled "_Pooling(symbol)" args =>+           String -> ArgsHMap "_Pooling(symbol)" args -> IO SymbolHandle+_Pooling name args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("pool_type",) . showValue <$>+                 (args !? #pool_type ::+                    Maybe (EnumType '["avg", "lp", "max", "sum"])),+               ("global_pool",) . showValue <$>+                 (args !? #global_pool :: Maybe Bool),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("pooling_convention",) . showValue <$>+                 (args !? #pooling_convention ::+                    Maybe (EnumType '["full", "valid"])),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("p_value",) . showValue <$>+                 (args !? #p_value :: Maybe (Maybe Int)),+               ("count_include_pad",) . showValue <$>+                 (args !? #count_include_pad :: Maybe (Maybe Bool))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Pooling(symbol)" = '[]++_backward_Pooling ::+                  forall args . Fullfilled "_backward_Pooling(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_Pooling(symbol)" args -> IO SymbolHandle+_backward_Pooling name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Deconvolution(symbol)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("adj", AttrOpt [Int]), '("target_shape", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("cudnn_tune",+          AttrOpt+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+        '("cudnn_off", AttrOpt Bool),+        '("layout",+          AttrOpt+            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),+        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),+        '("bias", AttrOpt SymbolHandle)]++_Deconvolution ::+               forall args . Fullfilled "_Deconvolution(symbol)" args =>+                 String -> ArgsHMap "_Deconvolution(symbol)" args -> IO SymbolHandle+_Deconvolution name args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Deconvolution"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Deconvolution(symbol)" = '[]++_backward_Deconvolution ::+                        forall args . Fullfilled "_backward_Deconvolution(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_Deconvolution(symbol)" args -> IO SymbolHandle+_backward_Deconvolution name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Deconvolution"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Activation(symbol)" =+     '[ '("act_type",+          AttrReq+            (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"])),+        '("data", AttrOpt SymbolHandle)]++_Activation ::+            forall args . Fullfilled "_Activation(symbol)" args =>+              String -> ArgsHMap "_Activation(symbol)" args -> IO SymbolHandle+_Activation name args+  = let scalarArgs+          = catMaybes+              [("act_type",) . showValue <$>+                 (args !? #act_type ::+                    Maybe+                      (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Activation"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Activation(symbol)" = '[]++_backward_Activation ::+                     forall args . Fullfilled "_backward_Activation(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_Activation(symbol)" args -> IO SymbolHandle+_backward_Activation name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Activation"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_UpSampling(symbol)" =+     '[ '("scale", AttrReq Int), '("num_filter", AttrOpt Int),+        '("sample_type", AttrReq (EnumType '["bilinear", "nearest"])),+        '("multi_input_mode", AttrOpt (EnumType '["concat", "sum"])),+        '("num_args", AttrReq Int), '("workspace", AttrOpt Int),+        '("data", AttrOpt [SymbolHandle])]++_UpSampling ::+            forall args . Fullfilled "_UpSampling(symbol)" args =>+              String -> ArgsHMap "_UpSampling(symbol)" args -> IO SymbolHandle+_UpSampling name args+  = let scalarArgs+          = catMaybes+              [("scale",) . showValue <$> (args !? #scale :: Maybe Int),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("sample_type",) . showValue <$>+                 (args !? #sample_type ::+                    Maybe (EnumType '["bilinear", "nearest"])),+               ("multi_input_mode",) . showValue <$>+                 (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])),+               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "UpSampling"+         sym <- if hasKey args #num_args then+                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals+                  else+                  mxSymbolCreateAtomicSymbol (fromOpHandle op)+                    ("num_args" : scalarkeys)+                    (showValue (length array) : scalarvals)+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_backward_UpSampling(symbol)" = '[]++_backward_UpSampling ::+                     forall args . Fullfilled "_backward_UpSampling(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_UpSampling(symbol)" args -> IO SymbolHandle+_backward_UpSampling name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_UpSampling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_BatchNorm(symbol)" =+     '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float),+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),+        '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int),+        '("cudnn_off", AttrOpt Bool), '("data", AttrOpt SymbolHandle),+        '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle),+        '("moving_mean", AttrOpt SymbolHandle),+        '("moving_var", AttrOpt SymbolHandle)]++_BatchNorm ::+           forall args . Fullfilled "_BatchNorm(symbol)" args =>+             String -> ArgsHMap "_BatchNorm(symbol)" args -> IO SymbolHandle+_BatchNorm name args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),+               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle),+               ("moving_mean",) <$> (args !? #moving_mean :: Maybe SymbolHandle),+               ("moving_var",) <$> (args !? #moving_var :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BatchNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_BatchNorm(symbol)" = '[]++_backward_BatchNorm ::+                    forall args . Fullfilled "_backward_BatchNorm(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_BatchNorm(symbol)" args -> IO SymbolHandle+_backward_BatchNorm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BatchNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_FullyConnected(symbol)" =+     '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool),+        '("flatten", AttrOpt Bool), '("data", AttrOpt SymbolHandle),+        '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle)]++_FullyConnected ::+                forall args . Fullfilled "_FullyConnected(symbol)" args =>+                  String ->+                    ArgsHMap "_FullyConnected(symbol)" args -> IO SymbolHandle+_FullyConnected name args+  = let scalarArgs+          = catMaybes+              [("num_hidden",) . showValue <$>+                 (args !? #num_hidden :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "FullyConnected"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_FullyConnected(symbol)" =+     '[]++_backward_FullyConnected ::+                         forall args . Fullfilled "_backward_FullyConnected(symbol)" args =>+                           String ->+                             ArgsHMap "_backward_FullyConnected(symbol)" args -> IO SymbolHandle+_backward_FullyConnected name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_FullyConnected"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Convolution(symbol)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("cudnn_tune",+          AttrOpt+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+        '("cudnn_off", AttrOpt Bool),+        '("layout",+          AttrOpt+            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),+        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),+        '("bias", AttrOpt SymbolHandle)]++_Convolution ::+             forall args . Fullfilled "_Convolution(symbol)" args =>+               String -> ArgsHMap "_Convolution(symbol)" args -> IO SymbolHandle+_Convolution name args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Convolution"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Convolution(symbol)" = '[]++_backward_Convolution ::+                      forall args . Fullfilled "_backward_Convolution(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_Convolution(symbol)" args -> IO SymbolHandle+_backward_Convolution name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Convolution"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_LayerNorm(symbol)" =+     '[ '("axis", AttrOpt Int), '("eps", AttrOpt Float),+        '("output_mean_var", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle), '("gamma", AttrOpt SymbolHandle),+        '("beta", AttrOpt SymbolHandle)]++_LayerNorm ::+           forall args . Fullfilled "_LayerNorm(symbol)" args =>+             String -> ArgsHMap "_LayerNorm(symbol)" args -> IO SymbolHandle+_LayerNorm name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),+               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LayerNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_LayerNorm(symbol)" = '[]++_backward_LayerNorm ::+                    forall args . Fullfilled "_backward_LayerNorm(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_LayerNorm(symbol)" args -> IO SymbolHandle+_backward_LayerNorm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LayerNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Concat(symbol)" =+     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),+        '("data", AttrOpt [SymbolHandle])]++_Concat ::+        forall args . Fullfilled "_Concat(symbol)" args =>+          String -> ArgsHMap "_Concat(symbol)" args -> IO SymbolHandle+_Concat name args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "Concat"+         sym <- if hasKey args #num_args then+                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals+                  else+                  mxSymbolCreateAtomicSymbol (fromOpHandle op)+                    ("num_args" : scalarkeys)+                    (showValue (length array) : scalarvals)+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_backward_Concat(symbol)" = '[]++_backward_Concat ::+                 forall args . Fullfilled "_backward_Concat(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_Concat(symbol)" args -> IO SymbolHandle+_backward_Concat name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Concat"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_rnn_param_concat(symbol)" =+     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),+        '("data", AttrOpt [SymbolHandle])]++_rnn_param_concat ::+                  forall args . Fullfilled "_rnn_param_concat(symbol)" args =>+                    String ->+                      ArgsHMap "_rnn_param_concat(symbol)" args -> IO SymbolHandle+_rnn_param_concat name args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "_rnn_param_concat"+         sym <- if hasKey args #num_args then+                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals+                  else+                  mxSymbolCreateAtomicSymbol (fromOpHandle op)+                    ("num_args" : scalarkeys)+                    (showValue (length array) : scalarvals)+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_SoftmaxActivation(symbol)" =+     '[ '("mode", AttrOpt (EnumType '["channel", "instance"])),+        '("data", AttrOpt SymbolHandle)]++_SoftmaxActivation ::+                   forall args . Fullfilled "_SoftmaxActivation(symbol)" args =>+                     String ->+                       ArgsHMap "_SoftmaxActivation(symbol)" args -> IO SymbolHandle+_SoftmaxActivation name args+  = let scalarArgs+          = catMaybes+              [("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["channel", "instance"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SoftmaxActivation"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SoftmaxActivation(symbol)" =+     '[]++_backward_SoftmaxActivation ::+                            forall args .+                              Fullfilled "_backward_SoftmaxActivation(symbol)" args =>+                              String ->+                                ArgsHMap "_backward_SoftmaxActivation(symbol)" args ->+                                  IO SymbolHandle+_backward_SoftmaxActivation name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SoftmaxActivation"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_LRN(symbol)" =+     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),+        '("knorm", AttrOpt Float), '("nsize", AttrReq Int),+        '("data", AttrOpt SymbolHandle)]++_LRN ::+     forall args . Fullfilled "_LRN(symbol)" args =>+       String -> ArgsHMap "_LRN(symbol)" args -> IO SymbolHandle+_LRN name args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float),+               ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LRN"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_LRN(symbol)" = '[]++_backward_LRN ::+              forall args . Fullfilled "_backward_LRN(symbol)" args =>+                String -> ArgsHMap "_backward_LRN(symbol)" args -> IO SymbolHandle+_backward_LRN name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LRN"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Dropout(symbol)" =+     '[ '("p", AttrOpt Float),+        '("mode", AttrOpt (EnumType '["always", "training"])),+        '("axes", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]++_Dropout ::+         forall args . Fullfilled "_Dropout(symbol)" args =>+           String -> ArgsHMap "_Dropout(symbol)" args -> IO SymbolHandle+_Dropout name args+  = let scalarArgs+          = catMaybes+              [("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["always", "training"])),+               ("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Dropout"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Dropout(symbol)" = '[]++_backward_Dropout ::+                  forall args . Fullfilled "_backward_Dropout(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_Dropout(symbol)" args -> IO SymbolHandle+_backward_Dropout name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Dropout"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_dequantize(symbol)" =+     '[ '("out_type", AttrOpt (EnumType '["float32"])),+        '("data", AttrOpt SymbolHandle),+        '("min_range", AttrOpt SymbolHandle),+        '("max_range", AttrOpt SymbolHandle)]++_contrib_dequantize ::+                    forall args . Fullfilled "_contrib_dequantize(symbol)" args =>+                      String ->+                        ArgsHMap "_contrib_dequantize(symbol)" args -> IO SymbolHandle+_contrib_dequantize name args+  = let scalarArgs+          = catMaybes+              [("out_type",) . showValue <$>+                 (args !? #out_type :: Maybe (EnumType '["float32"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle),+               ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_dequantize"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_quantized_flatten(symbol)" =+     '[ '("data", AttrOpt SymbolHandle),+        '("min_data", AttrOpt SymbolHandle),+        '("max_data", AttrOpt SymbolHandle)]++_contrib_quantized_flatten ::+                           forall args .+                             Fullfilled "_contrib_quantized_flatten(symbol)" args =>+                             String ->+                               ArgsHMap "_contrib_quantized_flatten(symbol)" args ->+                                 IO SymbolHandle+_contrib_quantized_flatten name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_flatten"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_quantized_conv(symbol)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("cudnn_tune",+          AttrOpt+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+        '("cudnn_off", AttrOpt Bool),+        '("layout",+          AttrOpt+            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),+        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),+        '("bias", AttrOpt SymbolHandle),+        '("min_data", AttrOpt SymbolHandle),+        '("max_data", AttrOpt SymbolHandle),+        '("min_weight", AttrOpt SymbolHandle),+        '("max_weight", AttrOpt SymbolHandle),+        '("min_bias", AttrOpt SymbolHandle),+        '("max_bias", AttrOpt SymbolHandle)]++_contrib_quantized_conv ::+                        forall args . Fullfilled "_contrib_quantized_conv(symbol)" args =>+                          String ->+                            ArgsHMap "_contrib_quantized_conv(symbol)" args -> IO SymbolHandle+_contrib_quantized_conv name args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle),+               ("min_weight",) <$> (args !? #min_weight :: Maybe SymbolHandle),+               ("max_weight",) <$> (args !? #max_weight :: Maybe SymbolHandle),+               ("min_bias",) <$> (args !? #min_bias :: Maybe SymbolHandle),+               ("max_bias",) <$> (args !? #max_bias :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_conv"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_contrib_quantized_fully_connected(symbol)" =+     '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool),+        '("flatten", AttrOpt Bool), '("data", AttrOpt SymbolHandle),+        '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle),+        '("min_data", AttrOpt SymbolHandle),+        '("max_data", AttrOpt SymbolHandle),+        '("min_weight", AttrOpt SymbolHandle),+        '("max_weight", AttrOpt SymbolHandle),+        '("min_bias", AttrOpt SymbolHandle),+        '("max_bias", AttrOpt SymbolHandle)]++_contrib_quantized_fully_connected ::+                                   forall args .+                                     Fullfilled "_contrib_quantized_fully_connected(symbol)" args =>+                                     String ->+                                       ArgsHMap "_contrib_quantized_fully_connected(symbol)" args ->+                                         IO SymbolHandle+_contrib_quantized_fully_connected name args+  = let scalarArgs+          = catMaybes+              [("num_hidden",) . showValue <$>+                 (args !? #num_hidden :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle),+               ("min_weight",) <$> (args !? #min_weight :: Maybe SymbolHandle),+               ("max_weight",) <$> (args !? #max_weight :: Maybe SymbolHandle),+               ("min_bias",) <$> (args !? #min_bias :: Maybe SymbolHandle),+               ("max_bias",) <$> (args !? #max_bias :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_fully_connected"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_quantized_pooling(symbol)" =+     '[ '("kernel", AttrOpt [Int]),+        '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])),+        '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool),+        '("pooling_convention", AttrOpt (EnumType '["full", "valid"])),+        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("p_value", AttrOpt (Maybe Int)),+        '("count_include_pad", AttrOpt (Maybe Bool)),+        '("data", AttrOpt SymbolHandle),+        '("min_data", AttrOpt SymbolHandle),+        '("max_data", AttrOpt SymbolHandle)]++_contrib_quantized_pooling ::+                           forall args .+                             Fullfilled "_contrib_quantized_pooling(symbol)" args =>+                             String ->+                               ArgsHMap "_contrib_quantized_pooling(symbol)" args ->+                                 IO SymbolHandle+_contrib_quantized_pooling name args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("pool_type",) . showValue <$>+                 (args !? #pool_type ::+                    Maybe (EnumType '["avg", "lp", "max", "sum"])),+               ("global_pool",) . showValue <$>+                 (args !? #global_pool :: Maybe Bool),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("pooling_convention",) . showValue <$>+                 (args !? #pooling_convention ::+                    Maybe (EnumType '["full", "valid"])),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("p_value",) . showValue <$>+                 (args !? #p_value :: Maybe (Maybe Int)),+               ("count_include_pad",) . showValue <$>+                 (args !? #count_include_pad :: Maybe (Maybe Bool))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_pooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_requantize(symbol)" =+     '[ '("min_calib_range", AttrOpt (Maybe Float)),+        '("max_calib_range", AttrOpt (Maybe Float)),+        '("data", AttrOpt SymbolHandle),+        '("min_range", AttrOpt SymbolHandle),+        '("max_range", AttrOpt SymbolHandle)]++_contrib_requantize ::+                    forall args . Fullfilled "_contrib_requantize(symbol)" args =>+                      String ->+                        ArgsHMap "_contrib_requantize(symbol)" args -> IO SymbolHandle+_contrib_requantize name args+  = let scalarArgs+          = catMaybes+              [("min_calib_range",) . showValue <$>+                 (args !? #min_calib_range :: Maybe (Maybe Float)),+               ("max_calib_range",) . showValue <$>+                 (args !? #max_calib_range :: Maybe (Maybe Float))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle),+               ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_requantize"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_quantize(symbol)" =+     '[ '("out_type", AttrOpt (EnumType '["int8", "uint8"])),+        '("data", AttrOpt SymbolHandle),+        '("min_range", AttrOpt SymbolHandle),+        '("max_range", AttrOpt SymbolHandle)]++_contrib_quantize ::+                  forall args . Fullfilled "_contrib_quantize(symbol)" args =>+                    String ->+                      ArgsHMap "_contrib_quantize(symbol)" args -> IO SymbolHandle+_contrib_quantize name args+  = let scalarArgs+          = catMaybes+              [("out_type",) . showValue <$>+                 (args !? #out_type :: Maybe (EnumType '["int8", "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle),+               ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantize"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_cvimread(symbol)" =+     '[ '("filename", AttrReq String), '("flag", AttrOpt Int),+        '("to_rgb", AttrOpt Bool)]++_cvimread ::+          forall args . Fullfilled "_cvimread(symbol)" args =>+            String -> ArgsHMap "_cvimread(symbol)" args -> IO SymbolHandle+_cvimread name args+  = let scalarArgs+          = catMaybes+              [("filename",) . showValue <$> (args !? #filename :: Maybe String),+               ("flag",) . showValue <$> (args !? #flag :: Maybe Int),+               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_cvimread"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_NoGradient(symbol)" = '[]++_NoGradient ::+            forall args . Fullfilled "_NoGradient(symbol)" args =>+              String -> ArgsHMap "_NoGradient(symbol)" args -> IO SymbolHandle+_NoGradient name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_NoGradient"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_CachedOp(symbol)" = '[]++_CachedOp ::+          forall args . Fullfilled "_CachedOp(symbol)" args =>+            String -> ArgsHMap "_CachedOp(symbol)" args -> IO SymbolHandle+_CachedOp name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_CachedOp"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_CachedOp(symbol)" = '[]++_backward_CachedOp ::+                   forall args . Fullfilled "_backward_CachedOp(symbol)" args =>+                     String ->+                       ArgsHMap "_backward_CachedOp(symbol)" args -> IO SymbolHandle+_backward_CachedOp name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_CachedOp"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "softmax_cross_entropy(symbol)" =+     '[ '("data", AttrOpt SymbolHandle),+        '("label", AttrOpt SymbolHandle)]++softmax_cross_entropy ::+                      forall args . Fullfilled "softmax_cross_entropy(symbol)" args =>+                        String ->+                          ArgsHMap "softmax_cross_entropy(symbol)" args -> IO SymbolHandle+softmax_cross_entropy name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softmax_cross_entropy"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward_softmax_cross_entropy(symbol)" = '[]++_backward_softmax_cross_entropy ::+                                forall args .+                                  Fullfilled "_backward_softmax_cross_entropy(symbol)" args =>+                                  String ->+                                    ArgsHMap "_backward_softmax_cross_entropy(symbol)" args ->+                                      IO SymbolHandle+_backward_softmax_cross_entropy name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_softmax_cross_entropy"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Pad(symbol)" =+     '[ '("mode", AttrReq (EnumType '["constant", "edge", "reflect"])),+        '("pad_width", AttrReq [Int]), '("constant_value", AttrOpt Double),+        '("data", AttrOpt SymbolHandle)]++_Pad ::+     forall args . Fullfilled "_Pad(symbol)" args =>+       String -> ArgsHMap "_Pad(symbol)" args -> IO SymbolHandle+_Pad name args+  = let scalarArgs+          = catMaybes+              [("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["constant", "edge", "reflect"])),+               ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]),+               ("constant_value",) . showValue <$>+                 (args !? #constant_value :: Maybe Double)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pad"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_foreach(symbol)" = '[]++_backward_foreach ::+                  forall args . Fullfilled "_backward_foreach(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_foreach(symbol)" args -> IO SymbolHandle+_backward_foreach name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_foreach"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_while_loop(symbol)" = '[]++_backward_while_loop ::+                     forall args . Fullfilled "_backward_while_loop(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_while_loop(symbol)" args -> IO SymbolHandle+_backward_while_loop name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_while_loop"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_cond(symbol)" = '[]++_backward_cond ::+               forall args . Fullfilled "_backward_cond(symbol)" args =>+                 String -> ArgsHMap "_backward_cond(symbol)" args -> IO SymbolHandle+_backward_cond name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cond"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_LeakyReLU(symbol)" =+     '[ '("act_type",+          AttrOpt (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])),+        '("slope", AttrOpt Float), '("lower_bound", AttrOpt Float),+        '("upper_bound", AttrOpt Float), '("data", AttrOpt SymbolHandle),+        '("gamma", AttrOpt SymbolHandle)]++_LeakyReLU ::+           forall args . Fullfilled "_LeakyReLU(symbol)" args =>+             String -> ArgsHMap "_LeakyReLU(symbol)" args -> IO SymbolHandle+_LeakyReLU name args+  = let scalarArgs+          = catMaybes+              [("act_type",) . showValue <$>+                 (args !? #act_type ::+                    Maybe (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])),+               ("slope",) . showValue <$> (args !? #slope :: Maybe Float),+               ("lower_bound",) . showValue <$>+                 (args !? #lower_bound :: Maybe Float),+               ("upper_bound",) . showValue <$>+                 (args !? #upper_bound :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LeakyReLU"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SwapAxis(symbol)" =+     '[ '("dim1", AttrOpt Int), '("dim2", AttrOpt Int),+        '("data", AttrOpt SymbolHandle)]++_SwapAxis ::+          forall args . Fullfilled "_SwapAxis(symbol)" args =>+            String -> ArgsHMap "_SwapAxis(symbol)" args -> IO SymbolHandle+_SwapAxis name args+  = let scalarArgs+          = catMaybes+              [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int),+               ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SwapAxis"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_IdentityAttachKLSparseReg(symbol)" =+     '[ '("sparseness_target", AttrOpt Float),+        '("penalty", AttrOpt Float), '("momentum", AttrOpt Float),+        '("data", AttrOpt SymbolHandle)]++_IdentityAttachKLSparseReg ::+                           forall args .+                             Fullfilled "_IdentityAttachKLSparseReg(symbol)" args =>+                             String ->+                               ArgsHMap "_IdentityAttachKLSparseReg(symbol)" args ->+                                 IO SymbolHandle+_IdentityAttachKLSparseReg name args+  = let scalarArgs+          = catMaybes+              [("sparseness_target",) . showValue <$>+                 (args !? #sparseness_target :: Maybe Float),+               ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "IdentityAttachKLSparseReg"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SliceChannel(symbol)" =+     '[ '("num_outputs", AttrReq Int), '("axis", AttrOpt Int),+        '("squeeze_axis", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++_SliceChannel ::+              forall args . Fullfilled "_SliceChannel(symbol)" args =>+                String -> ArgsHMap "_SliceChannel(symbol)" args -> IO SymbolHandle+_SliceChannel name args+  = let scalarArgs+          = catMaybes+              [("num_outputs",) . showValue <$>+                 (args !? #num_outputs :: Maybe Int),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("squeeze_axis",) . showValue <$>+                 (args !? #squeeze_axis :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SliceChannel"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_BatchNorm_v1(symbol)" =+     '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float),+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),+        '("output_mean_var", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle), '("gamma", AttrOpt SymbolHandle),+        '("beta", AttrOpt SymbolHandle)]++_BatchNorm_v1 ::+              forall args . Fullfilled "_BatchNorm_v1(symbol)" args =>+                String -> ArgsHMap "_BatchNorm_v1(symbol)" args -> IO SymbolHandle+_BatchNorm_v1 name args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),+               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BatchNorm_v1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "signsgd_update(symbol)" =+     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle)]++signsgd_update ::+               forall args . Fullfilled "signsgd_update(symbol)" args =>+                 String -> ArgsHMap "signsgd_update(symbol)" args -> IO SymbolHandle+signsgd_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "signsgd_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "signum_update(symbol)" =+     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("wd_lh", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("mom", AttrOpt SymbolHandle)]++signum_update ::+              forall args . Fullfilled "signum_update(symbol)" args =>+                String -> ArgsHMap "signum_update(symbol)" args -> IO SymbolHandle+signum_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("wd_lh",) . showValue <$> (args !? #wd_lh :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("mom",) <$> (args !? #mom :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "signum_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sgd_update(symbol)" =+     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle)]++sgd_update ::+           forall args . Fullfilled "sgd_update(symbol)" args =>+             String -> ArgsHMap "sgd_update(symbol)" args -> IO SymbolHandle+sgd_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sgd_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sgd_mom_update(symbol)" =+     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("mom", AttrOpt SymbolHandle)]++sgd_mom_update ::+               forall args . Fullfilled "sgd_mom_update(symbol)" args =>+                 String -> ArgsHMap "sgd_mom_update(symbol)" args -> IO SymbolHandle+sgd_mom_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("mom",) <$> (args !? #mom :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sgd_mom_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "mp_sgd_update(symbol)" =+     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("weight32", AttrOpt SymbolHandle)]++mp_sgd_update ::+              forall args . Fullfilled "mp_sgd_update(symbol)" args =>+                String -> ArgsHMap "mp_sgd_update(symbol)" args -> IO SymbolHandle+mp_sgd_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mp_sgd_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "mp_sgd_mom_update(symbol)" =+     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("mom", AttrOpt SymbolHandle),+        '("weight32", AttrOpt SymbolHandle)]++mp_sgd_mom_update ::+                  forall args . Fullfilled "mp_sgd_mom_update(symbol)" args =>+                    String ->+                      ArgsHMap "mp_sgd_mom_update(symbol)" args -> IO SymbolHandle+mp_sgd_mom_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("mom",) <$> (args !? #mom :: Maybe SymbolHandle),+               ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mp_sgd_mom_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "ftml_update(symbol)" =+     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),+        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Double),+        '("t", AttrReq Int), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float), '("clip_grad", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("d", AttrOpt SymbolHandle), '("v", AttrOpt SymbolHandle),+        '("z", AttrOpt SymbolHandle)]++ftml_update ::+            forall args . Fullfilled "ftml_update(symbol)" args =>+              String -> ArgsHMap "ftml_update(symbol)" args -> IO SymbolHandle+ftml_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Double),+               ("t",) . showValue <$> (args !? #t :: Maybe Int),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_grad",) . showValue <$> (args !? #clip_grad :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("d",) <$> (args !? #d :: Maybe SymbolHandle),+               ("v",) <$> (args !? #v :: Maybe SymbolHandle),+               ("z",) <$> (args !? #z :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ftml_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "adam_update(symbol)" =+     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),+        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("mean", AttrOpt SymbolHandle), '("var", AttrOpt SymbolHandle)]++adam_update ::+            forall args . Fullfilled "adam_update(symbol)" args =>+              String -> ArgsHMap "adam_update(symbol)" args -> IO SymbolHandle+adam_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("mean",) <$> (args !? #mean :: Maybe SymbolHandle),+               ("var",) <$> (args !? #var :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "adam_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "rmsprop_update(symbol)" =+     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),+        '("epsilon", AttrOpt Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("clip_weights", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("n", AttrOpt SymbolHandle)]++rmsprop_update ::+               forall args . Fullfilled "rmsprop_update(symbol)" args =>+                 String -> ArgsHMap "rmsprop_update(symbol)" args -> IO SymbolHandle+rmsprop_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("clip_weights",) . showValue <$>+                 (args !? #clip_weights :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("n",) <$> (args !? #n :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rmsprop_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "rmspropalex_update(symbol)" =+     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),+        '("gamma2", AttrOpt Float), '("epsilon", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("clip_weights", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("n", AttrOpt SymbolHandle), '("g", AttrOpt SymbolHandle),+        '("delta", AttrOpt SymbolHandle)]++rmspropalex_update ::+                   forall args . Fullfilled "rmspropalex_update(symbol)" args =>+                     String ->+                       ArgsHMap "rmspropalex_update(symbol)" args -> IO SymbolHandle+rmspropalex_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),+               ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("clip_weights",) . showValue <$>+                 (args !? #clip_weights :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("n",) <$> (args !? #n :: Maybe SymbolHandle),+               ("g",) <$> (args !? #g :: Maybe SymbolHandle),+               ("delta",) <$> (args !? #delta :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rmspropalex_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "ftrl_update(symbol)" =+     '[ '("lr", AttrReq Float), '("lamda1", AttrOpt Float),+        '("beta", AttrOpt Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("z", AttrOpt SymbolHandle), '("n", AttrOpt SymbolHandle)]++ftrl_update ::+            forall args . Fullfilled "ftrl_update(symbol)" args =>+              String -> ArgsHMap "ftrl_update(symbol)" args -> IO SymbolHandle+ftrl_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("z",) <$> (args !? #z :: Maybe SymbolHandle),+               ("n",) <$> (args !? #n :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ftrl_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sparse_adagrad_update(symbol)" =+     '[ '("lr", AttrReq Float), '("epsilon", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("history", AttrOpt SymbolHandle)]++_sparse_adagrad_update ::+                       forall args . Fullfilled "_sparse_adagrad_update(symbol)" args =>+                         String ->+                           ArgsHMap "_sparse_adagrad_update(symbol)" args -> IO SymbolHandle+_sparse_adagrad_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("history",) <$> (args !? #history :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sparse_adagrad_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_LinearRegressionOutput(symbol)" =+     '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle),+        '("label", AttrOpt SymbolHandle)]++_LinearRegressionOutput ::+                        forall args . Fullfilled "_LinearRegressionOutput(symbol)" args =>+                          String ->+                            ArgsHMap "_LinearRegressionOutput(symbol)" args -> IO SymbolHandle+_LinearRegressionOutput name args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LinearRegressionOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linear_reg_out(symbol)" =+     '[]++_backward_linear_reg_out ::+                         forall args . Fullfilled "_backward_linear_reg_out(symbol)" args =>+                           String ->+                             ArgsHMap "_backward_linear_reg_out(symbol)" args -> IO SymbolHandle+_backward_linear_reg_out name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linear_reg_out"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_MAERegressionOutput(symbol)" =+     '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle),+        '("label", AttrOpt SymbolHandle)]++_MAERegressionOutput ::+                     forall args . Fullfilled "_MAERegressionOutput(symbol)" args =>+                       String ->+                         ArgsHMap "_MAERegressionOutput(symbol)" args -> IO SymbolHandle+_MAERegressionOutput name args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "MAERegressionOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_mae_reg_out(symbol)" = '[]++_backward_mae_reg_out ::+                      forall args . Fullfilled "_backward_mae_reg_out(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_mae_reg_out(symbol)" args -> IO SymbolHandle+_backward_mae_reg_out name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mae_reg_out"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_LogisticRegressionOutput(symbol)" =+     '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle),+        '("label", AttrOpt SymbolHandle)]++_LogisticRegressionOutput ::+                          forall args .+                            Fullfilled "_LogisticRegressionOutput(symbol)" args =>+                            String ->+                              ArgsHMap "_LogisticRegressionOutput(symbol)" args ->+                                IO SymbolHandle+_LogisticRegressionOutput name args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LogisticRegressionOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_logistic_reg_out(symbol)" =+     '[]++_backward_logistic_reg_out ::+                           forall args .+                             Fullfilled "_backward_logistic_reg_out(symbol)" args =>+                             String ->+                               ArgsHMap "_backward_logistic_reg_out(symbol)" args ->+                                 IO SymbolHandle+_backward_logistic_reg_out name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_logistic_reg_out"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_CustomFunction(symbol)" = '[]++_CustomFunction ::+                forall args . Fullfilled "_CustomFunction(symbol)" args =>+                  String ->+                    ArgsHMap "_CustomFunction(symbol)" args -> IO SymbolHandle+_CustomFunction name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_CustomFunction"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_CustomFunction(symbol)" =+     '[]++_backward_CustomFunction ::+                         forall args . Fullfilled "_backward_CustomFunction(symbol)" args =>+                           String ->+                             ArgsHMap "_backward_CustomFunction(symbol)" args -> IO SymbolHandle+_backward_CustomFunction name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_CustomFunction"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward__Native(symbol)" = '[]++_backward__Native ::+                  forall args . Fullfilled "_backward__Native(symbol)" args =>+                    String ->+                      ArgsHMap "_backward__Native(symbol)" args -> IO SymbolHandle+_backward__Native name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__Native"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward__NDArray(symbol)" = '[]++_backward__NDArray ::+                   forall args . Fullfilled "_backward__NDArray(symbol)" args =>+                     String ->+                       ArgsHMap "_backward__NDArray(symbol)" args -> IO SymbolHandle+_backward__NDArray name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__NDArray"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_MultiBoxTarget(symbol)" =+     '[ '("overlap_threshold", AttrOpt Float),+        '("ignore_label", AttrOpt Float),+        '("negative_mining_ratio", AttrOpt Float),+        '("negative_mining_thresh", AttrOpt Float),+        '("minimum_negative_samples", AttrOpt Int),+        '("variances", AttrOpt [Float]), '("anchor", AttrOpt SymbolHandle),+        '("label", AttrOpt SymbolHandle),+        '("cls_pred", AttrOpt SymbolHandle)]++_contrib_MultiBoxTarget ::+                        forall args . Fullfilled "_contrib_MultiBoxTarget(symbol)" args =>+                          String ->+                            ArgsHMap "_contrib_MultiBoxTarget(symbol)" args -> IO SymbolHandle+_contrib_MultiBoxTarget name args+  = let scalarArgs+          = catMaybes+              [("overlap_threshold",) . showValue <$>+                 (args !? #overlap_threshold :: Maybe Float),+               ("ignore_label",) . showValue <$>+                 (args !? #ignore_label :: Maybe Float),+               ("negative_mining_ratio",) . showValue <$>+                 (args !? #negative_mining_ratio :: Maybe Float),+               ("negative_mining_thresh",) . showValue <$>+                 (args !? #negative_mining_thresh :: Maybe Float),+               ("minimum_negative_samples",) . showValue <$>+                 (args !? #minimum_negative_samples :: Maybe Int),+               ("variances",) . showValue <$>+                 (args !? #variances :: Maybe [Float])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("anchor",) <$> (args !? #anchor :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle),+               ("cls_pred",) <$> (args !? #cls_pred :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxTarget"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_MultiBoxTarget(symbol)" = '[]++_backward__contrib_MultiBoxTarget ::+                                  forall args .+                                    Fullfilled "_backward__contrib_MultiBoxTarget(symbol)" args =>+                                    String ->+                                      ArgsHMap "_backward__contrib_MultiBoxTarget(symbol)" args ->+                                        IO SymbolHandle+_backward__contrib_MultiBoxTarget name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_Proposal(symbol)" =+     '[ '("rpn_pre_nms_top_n", AttrOpt Int),+        '("rpn_post_nms_top_n", AttrOpt Int),+        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),+        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),+        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),+        '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt SymbolHandle),+        '("bbox_pred", AttrOpt SymbolHandle),+        '("im_info", AttrOpt SymbolHandle)]++_contrib_Proposal ::+                  forall args . Fullfilled "_contrib_Proposal(symbol)" args =>+                    String ->+                      ArgsHMap "_contrib_Proposal(symbol)" args -> IO SymbolHandle+_contrib_Proposal name args+  = let scalarArgs+          = catMaybes+              [("rpn_pre_nms_top_n",) . showValue <$>+                 (args !? #rpn_pre_nms_top_n :: Maybe Int),+               ("rpn_post_nms_top_n",) . showValue <$>+                 (args !? #rpn_post_nms_top_n :: Maybe Int),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("rpn_min_size",) . showValue <$>+                 (args !? #rpn_min_size :: Maybe Int),+               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("feature_stride",) . showValue <$>+                 (args !? #feature_stride :: Maybe Int),+               ("output_score",) . showValue <$>+                 (args !? #output_score :: Maybe Bool),+               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle),+               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe SymbolHandle),+               ("im_info",) <$> (args !? #im_info :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_Proposal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward__contrib_Proposal(symbol)" =+     '[]++_backward__contrib_Proposal ::+                            forall args .+                              Fullfilled "_backward__contrib_Proposal(symbol)" args =>+                              String ->+                                ArgsHMap "_backward__contrib_Proposal(symbol)" args ->+                                  IO SymbolHandle+_backward__contrib_Proposal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_Proposal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_count_sketch(symbol)" =+     '[ '("out_dim", AttrReq Int),+        '("processing_batch_size", AttrOpt Int),+        '("data", AttrOpt SymbolHandle), '("h", AttrOpt SymbolHandle),+        '("s", AttrOpt SymbolHandle)]++_contrib_count_sketch ::+                      forall args . Fullfilled "_contrib_count_sketch(symbol)" args =>+                        String ->+                          ArgsHMap "_contrib_count_sketch(symbol)" args -> IO SymbolHandle+_contrib_count_sketch name args+  = let scalarArgs+          = catMaybes+              [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int),+               ("processing_batch_size",) . showValue <$>+                 (args !? #processing_batch_size :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("h",) <$> (args !? #h :: Maybe SymbolHandle),+               ("s",) <$> (args !? #s :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_count_sketch"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_count_sketch(symbol)" = '[]++_backward__contrib_count_sketch ::+                                forall args .+                                  Fullfilled "_backward__contrib_count_sketch(symbol)" args =>+                                  String ->+                                    ArgsHMap "_backward__contrib_count_sketch(symbol)" args ->+                                      IO SymbolHandle+_backward__contrib_count_sketch name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_count_sketch"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_MultiBoxDetection(symbol)" =+     '[ '("clip", AttrOpt Bool), '("threshold", AttrOpt Float),+        '("background_id", AttrOpt Int), '("nms_threshold", AttrOpt Float),+        '("force_suppress", AttrOpt Bool), '("variances", AttrOpt [Float]),+        '("nms_topk", AttrOpt Int), '("cls_prob", AttrOpt SymbolHandle),+        '("loc_pred", AttrOpt SymbolHandle),+        '("anchor", AttrOpt SymbolHandle)]++_contrib_MultiBoxDetection ::+                           forall args .+                             Fullfilled "_contrib_MultiBoxDetection(symbol)" args =>+                             String ->+                               ArgsHMap "_contrib_MultiBoxDetection(symbol)" args ->+                                 IO SymbolHandle+_contrib_MultiBoxDetection name args+  = let scalarArgs+          = catMaybes+              [("clip",) . showValue <$> (args !? #clip :: Maybe Bool),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("background_id",) . showValue <$>+                 (args !? #background_id :: Maybe Int),+               ("nms_threshold",) . showValue <$>+                 (args !? #nms_threshold :: Maybe Float),+               ("force_suppress",) . showValue <$>+                 (args !? #force_suppress :: Maybe Bool),+               ("variances",) . showValue <$>+                 (args !? #variances :: Maybe [Float]),+               ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle),+               ("loc_pred",) <$> (args !? #loc_pred :: Maybe SymbolHandle),+               ("anchor",) <$> (args !? #anchor :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxDetection"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_MultiBoxDetection(symbol)" = '[]++_backward__contrib_MultiBoxDetection ::+                                     forall args .+                                       Fullfilled "_backward__contrib_MultiBoxDetection(symbol)"+                                         args =>+                                       String ->+                                         ArgsHMap "_backward__contrib_MultiBoxDetection(symbol)"+                                           args+                                           -> IO SymbolHandle+_backward__contrib_MultiBoxDetection name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_contrib_DeformablePSROIPooling(symbol)" =+     '[ '("spatial_scale", AttrReq Float), '("output_dim", AttrReq Int),+        '("group_size", AttrReq Int), '("pooled_size", AttrReq Int),+        '("part_size", AttrOpt Int), '("sample_per_part", AttrOpt Int),+        '("trans_std", AttrOpt Float), '("no_trans", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle),+        '("trans", AttrOpt SymbolHandle)]++_contrib_DeformablePSROIPooling ::+                                forall args .+                                  Fullfilled "_contrib_DeformablePSROIPooling(symbol)" args =>+                                  String ->+                                    ArgsHMap "_contrib_DeformablePSROIPooling(symbol)" args ->+                                      IO SymbolHandle+_contrib_DeformablePSROIPooling name args+  = let scalarArgs+          = catMaybes+              [("spatial_scale",) . showValue <$>+                 (args !? #spatial_scale :: Maybe Float),+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),+               ("group_size",) . showValue <$> (args !? #group_size :: Maybe Int),+               ("pooled_size",) . showValue <$>+                 (args !? #pooled_size :: Maybe Int),+               ("part_size",) . showValue <$> (args !? #part_size :: Maybe Int),+               ("sample_per_part",) . showValue <$>+                 (args !? #sample_per_part :: Maybe Int),+               ("trans_std",) . showValue <$> (args !? #trans_std :: Maybe Float),+               ("no_trans",) . showValue <$> (args !? #no_trans :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle),+               ("trans",) <$> (args !? #trans :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_DeformablePSROIPooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_DeformablePSROIPooling(symbol)" =+     '[]++_backward__contrib_DeformablePSROIPooling ::+                                          forall args .+                                            Fullfilled+                                              "_backward__contrib_DeformablePSROIPooling(symbol)"+                                              args =>+                                            String ->+                                              ArgsHMap+                                                "_backward__contrib_DeformablePSROIPooling(symbol)"+                                                args+                                                -> IO SymbolHandle+_backward__contrib_DeformablePSROIPooling name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward__contrib_CTCLoss(symbol)" =+     '[]++_backward__contrib_CTCLoss ::+                           forall args .+                             Fullfilled "_backward__contrib_CTCLoss(symbol)" args =>+                             String ->+                               ArgsHMap "_backward__contrib_CTCLoss(symbol)" args ->+                                 IO SymbolHandle+_backward__contrib_CTCLoss name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_CTCLoss"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_MultiProposal(symbol)" =+     '[ '("rpn_pre_nms_top_n", AttrOpt Int),+        '("rpn_post_nms_top_n", AttrOpt Int),+        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),+        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),+        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),+        '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt SymbolHandle),+        '("bbox_pred", AttrOpt SymbolHandle),+        '("im_info", AttrOpt SymbolHandle)]++_contrib_MultiProposal ::+                       forall args . Fullfilled "_contrib_MultiProposal(symbol)" args =>+                         String ->+                           ArgsHMap "_contrib_MultiProposal(symbol)" args -> IO SymbolHandle+_contrib_MultiProposal name args+  = let scalarArgs+          = catMaybes+              [("rpn_pre_nms_top_n",) . showValue <$>+                 (args !? #rpn_pre_nms_top_n :: Maybe Int),+               ("rpn_post_nms_top_n",) . showValue <$>+                 (args !? #rpn_post_nms_top_n :: Maybe Int),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("rpn_min_size",) . showValue <$>+                 (args !? #rpn_min_size :: Maybe Int),+               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("feature_stride",) . showValue <$>+                 (args !? #feature_stride :: Maybe Int),+               ("output_score",) . showValue <$>+                 (args !? #output_score :: Maybe Bool),+               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle),+               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe SymbolHandle),+               ("im_info",) <$> (args !? #im_info :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiProposal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_MultiProposal(symbol)" = '[]++_backward__contrib_MultiProposal ::+                                 forall args .+                                   Fullfilled "_backward__contrib_MultiProposal(symbol)" args =>+                                   String ->+                                     ArgsHMap "_backward__contrib_MultiProposal(symbol)" args ->+                                       IO SymbolHandle+_backward__contrib_MultiProposal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiProposal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_MultiBoxPrior(symbol)" =+     '[ '("sizes", AttrOpt [Float]), '("ratios", AttrOpt [Float]),+        '("clip", AttrOpt Bool), '("steps", AttrOpt [Float]),+        '("offsets", AttrOpt [Float]), '("data", AttrOpt SymbolHandle)]++_contrib_MultiBoxPrior ::+                       forall args . Fullfilled "_contrib_MultiBoxPrior(symbol)" args =>+                         String ->+                           ArgsHMap "_contrib_MultiBoxPrior(symbol)" args -> IO SymbolHandle+_contrib_MultiBoxPrior name args+  = let scalarArgs+          = catMaybes+              [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("clip",) . showValue <$> (args !? #clip :: Maybe Bool),+               ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]),+               ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxPrior"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_MultiBoxPrior(symbol)" = '[]++_backward__contrib_MultiBoxPrior ::+                                 forall args .+                                   Fullfilled "_backward__contrib_MultiBoxPrior(symbol)" args =>+                                   String ->+                                     ArgsHMap "_backward__contrib_MultiBoxPrior(symbol)" args ->+                                       IO SymbolHandle+_backward__contrib_MultiBoxPrior name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_fft(symbol)" =+     '[ '("compute_size", AttrOpt Int), '("data", AttrOpt SymbolHandle)]++_contrib_fft ::+             forall args . Fullfilled "_contrib_fft(symbol)" args =>+               String -> ArgsHMap "_contrib_fft(symbol)" args -> IO SymbolHandle+_contrib_fft name args+  = let scalarArgs+          = catMaybes+              [("compute_size",) . showValue <$>+                 (args !? #compute_size :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_fft"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward__contrib_fft(symbol)" = '[]++_backward__contrib_fft ::+                       forall args . Fullfilled "_backward__contrib_fft(symbol)" args =>+                         String ->+                           ArgsHMap "_backward__contrib_fft(symbol)" args -> IO SymbolHandle+_backward__contrib_fft name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_fft"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_PSROIPooling(symbol)" =+     '[ '("spatial_scale", AttrReq Float), '("output_dim", AttrReq Int),+        '("pooled_size", AttrReq Int), '("group_size", AttrOpt Int),+        '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle)]++_contrib_PSROIPooling ::+                      forall args . Fullfilled "_contrib_PSROIPooling(symbol)" args =>+                        String ->+                          ArgsHMap "_contrib_PSROIPooling(symbol)" args -> IO SymbolHandle+_contrib_PSROIPooling name args+  = let scalarArgs+          = catMaybes+              [("spatial_scale",) . showValue <$>+                 (args !? #spatial_scale :: Maybe Float),+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),+               ("pooled_size",) . showValue <$>+                 (args !? #pooled_size :: Maybe Int),+               ("group_size",) . showValue <$> (args !? #group_size :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_PSROIPooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_PSROIPooling(symbol)" = '[]++_backward__contrib_PSROIPooling ::+                                forall args .+                                  Fullfilled "_backward__contrib_PSROIPooling(symbol)" args =>+                                  String ->+                                    ArgsHMap "_backward__contrib_PSROIPooling(symbol)" args ->+                                      IO SymbolHandle+_backward__contrib_PSROIPooling name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_PSROIPooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_contrib_DeformableConvolution(symbol)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("num_deformable_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("layout", AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NCW"]))),+        '("data", AttrOpt SymbolHandle), '("offset", AttrOpt SymbolHandle),+        '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle)]++_contrib_DeformableConvolution ::+                               forall args .+                                 Fullfilled "_contrib_DeformableConvolution(symbol)" args =>+                                 String ->+                                   ArgsHMap "_contrib_DeformableConvolution(symbol)" args ->+                                     IO SymbolHandle+_contrib_DeformableConvolution name args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("num_deformable_group",) . showValue <$>+                 (args !? #num_deformable_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("offset",) <$> (args !? #offset :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_DeformableConvolution"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_DeformableConvolution(symbol)" =+     '[]++_backward__contrib_DeformableConvolution ::+                                         forall args .+                                           Fullfilled+                                             "_backward__contrib_DeformableConvolution(symbol)"+                                             args =>+                                           String ->+                                             ArgsHMap+                                               "_backward__contrib_DeformableConvolution(symbol)"+                                               args+                                               -> IO SymbolHandle+_backward__contrib_DeformableConvolution name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_ifft(symbol)" =+     '[ '("compute_size", AttrOpt Int), '("data", AttrOpt SymbolHandle)]++_contrib_ifft ::+              forall args . Fullfilled "_contrib_ifft(symbol)" args =>+                String -> ArgsHMap "_contrib_ifft(symbol)" args -> IO SymbolHandle+_contrib_ifft name args+  = let scalarArgs+          = catMaybes+              [("compute_size",) . showValue <$>+                 (args !? #compute_size :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_ifft"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward__contrib_ifft(symbol)" = '[]++_backward__contrib_ifft ::+                        forall args . Fullfilled "_backward__contrib_ifft(symbol)" args =>+                          String ->+                            ArgsHMap "_backward__contrib_ifft(symbol)" args -> IO SymbolHandle+_backward__contrib_ifft name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_ifft"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_SyncBatchNorm(symbol)" = '[]++_backward__contrib_SyncBatchNorm ::+                                 forall args .+                                   Fullfilled "_backward__contrib_SyncBatchNorm(symbol)" args =>+                                   String ->+                                     ArgsHMap "_backward__contrib_SyncBatchNorm(symbol)" args ->+                                       IO SymbolHandle+_backward__contrib_SyncBatchNorm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_SyncBatchNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_InstanceNorm(symbol)" =+     '[ '("eps", AttrOpt Float), '("data", AttrOpt SymbolHandle),+        '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle)]++_InstanceNorm ::+              forall args . Fullfilled "_InstanceNorm(symbol)" args =>+                String -> ArgsHMap "_InstanceNorm(symbol)" args -> IO SymbolHandle+_InstanceNorm name args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),+               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "InstanceNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_InstanceNorm(symbol)" = '[]++_backward_InstanceNorm ::+                       forall args . Fullfilled "_backward_InstanceNorm(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_InstanceNorm(symbol)" args -> IO SymbolHandle+_backward_InstanceNorm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_InstanceNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SVMOutput(symbol)" =+     '[ '("margin", AttrOpt Float),+        '("regularization_coefficient", AttrOpt Float),+        '("use_linear", AttrOpt Bool), '("data", AttrOpt SymbolHandle),+        '("label", AttrOpt SymbolHandle)]++_SVMOutput ::+           forall args . Fullfilled "_SVMOutput(symbol)" args =>+             String -> ArgsHMap "_SVMOutput(symbol)" args -> IO SymbolHandle+_SVMOutput name args+  = let scalarArgs+          = catMaybes+              [("margin",) . showValue <$> (args !? #margin :: Maybe Float),+               ("regularization_coefficient",) . showValue <$>+                 (args !? #regularization_coefficient :: Maybe Float),+               ("use_linear",) . showValue <$>+                 (args !? #use_linear :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SVMOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SVMOutput(symbol)" = '[]++_backward_SVMOutput ::+                    forall args . Fullfilled "_backward_SVMOutput(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_SVMOutput(symbol)" args -> IO SymbolHandle+_backward_SVMOutput name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SVMOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_GridGenerator(symbol)" =+     '[ '("transform_type", AttrReq (EnumType '["affine", "warp"])),+        '("target_shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]++_GridGenerator ::+               forall args . Fullfilled "_GridGenerator(symbol)" args =>+                 String -> ArgsHMap "_GridGenerator(symbol)" args -> IO SymbolHandle+_GridGenerator name args+  = let scalarArgs+          = catMaybes+              [("transform_type",) . showValue <$>+                 (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "GridGenerator"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_GridGenerator(symbol)" = '[]++_backward_GridGenerator ::+                        forall args . Fullfilled "_backward_GridGenerator(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_GridGenerator(symbol)" args -> IO SymbolHandle+_backward_GridGenerator name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_GridGenerator"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Pad(symbol)" = '[]++_backward_Pad ::+              forall args . Fullfilled "_backward_Pad(symbol)" args =>+                String -> ArgsHMap "_backward_Pad(symbol)" args -> IO SymbolHandle+_backward_Pad name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pad"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Convolution_v1(symbol)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("cudnn_tune",+          AttrOpt+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+        '("cudnn_off", AttrOpt Bool),+        '("layout",+          AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"]))),+        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),+        '("bias", AttrOpt SymbolHandle)]++_Convolution_v1 ::+                forall args . Fullfilled "_Convolution_v1(symbol)" args =>+                  String ->+                    ArgsHMap "_Convolution_v1(symbol)" args -> IO SymbolHandle+_Convolution_v1 name args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Convolution_v1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Convolution_v1(symbol)" =+     '[]++_backward_Convolution_v1 ::+                         forall args . Fullfilled "_backward_Convolution_v1(symbol)" args =>+                           String ->+                             ArgsHMap "_backward_Convolution_v1(symbol)" args -> IO SymbolHandle+_backward_Convolution_v1 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Convolution_v1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SequenceReverse(symbol)" =+     '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int),+        '("data", AttrOpt SymbolHandle),+        '("sequence_length", AttrOpt SymbolHandle)]++_SequenceReverse ::+                 forall args . Fullfilled "_SequenceReverse(symbol)" args =>+                   String ->+                     ArgsHMap "_SequenceReverse(symbol)" args -> IO SymbolHandle+_SequenceReverse name args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceReverse"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SequenceReverse(symbol)" =+     '[]++_backward_SequenceReverse ::+                          forall args .+                            Fullfilled "_backward_SequenceReverse(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_SequenceReverse(symbol)" args ->+                                IO SymbolHandle+_backward_SequenceReverse name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceReverse"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SoftmaxOutput(symbol)" =+     '[ '("grad_scale", AttrOpt Float),+        '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool),+        '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool),+        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),+        '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float),+        '("data", AttrOpt SymbolHandle), '("label", AttrOpt SymbolHandle)]++_SoftmaxOutput ::+               forall args . Fullfilled "_SoftmaxOutput(symbol)" args =>+                 String -> ArgsHMap "_SoftmaxOutput(symbol)" args -> IO SymbolHandle+_SoftmaxOutput name args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float),+               ("ignore_label",) . showValue <$>+                 (args !? #ignore_label :: Maybe Float),+               ("multi_output",) . showValue <$>+                 (args !? #multi_output :: Maybe Bool),+               ("use_ignore",) . showValue <$>+                 (args !? #use_ignore :: Maybe Bool),+               ("preserve_shape",) . showValue <$>+                 (args !? #preserve_shape :: Maybe Bool),+               ("normalization",) . showValue <$>+                 (args !? #normalization ::+                    Maybe (EnumType '["batch", "null", "valid"])),+               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),+               ("smooth_alpha",) . showValue <$>+                 (args !? #smooth_alpha :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SoftmaxOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SoftmaxOutput(symbol)" = '[]++_backward_SoftmaxOutput ::+                        forall args . Fullfilled "_backward_SoftmaxOutput(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_SoftmaxOutput(symbol)" args -> IO SymbolHandle+_backward_SoftmaxOutput name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SoftmaxOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Softmax(symbol)" =+     '[ '("grad_scale", AttrOpt Float),+        '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool),+        '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool),+        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),+        '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float),+        '("data", AttrOpt SymbolHandle)]++_Softmax ::+         forall args . Fullfilled "_Softmax(symbol)" args =>+           String -> ArgsHMap "_Softmax(symbol)" args -> IO SymbolHandle+_Softmax name args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float),+               ("ignore_label",) . showValue <$>+                 (args !? #ignore_label :: Maybe Float),+               ("multi_output",) . showValue <$>+                 (args !? #multi_output :: Maybe Bool),+               ("use_ignore",) . showValue <$>+                 (args !? #use_ignore :: Maybe Bool),+               ("preserve_shape",) . showValue <$>+                 (args !? #preserve_shape :: Maybe Bool),+               ("normalization",) . showValue <$>+                 (args !? #normalization ::+                    Maybe (EnumType '["batch", "null", "valid"])),+               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),+               ("smooth_alpha",) . showValue <$>+                 (args !? #smooth_alpha :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Softmax"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Softmax(symbol)" = '[]++_backward_Softmax ::+                  forall args . Fullfilled "_backward_Softmax(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_Softmax(symbol)" args -> IO SymbolHandle+_backward_Softmax name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Softmax"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_BilinearSampler(symbol)" =+     '[ '("data", AttrOpt SymbolHandle),+        '("grid", AttrOpt SymbolHandle)]++_BilinearSampler ::+                 forall args . Fullfilled "_BilinearSampler(symbol)" args =>+                   String ->+                     ArgsHMap "_BilinearSampler(symbol)" args -> IO SymbolHandle+_BilinearSampler name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("grid",) <$> (args !? #grid :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BilinearSampler"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_BilinearSampler(symbol)" =+     '[]++_backward_BilinearSampler ::+                          forall args .+                            Fullfilled "_backward_BilinearSampler(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_BilinearSampler(symbol)" args ->+                                IO SymbolHandle+_backward_BilinearSampler name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BilinearSampler"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_LeakyReLU(symbol)" = '[]++_backward_LeakyReLU ::+                    forall args . Fullfilled "_backward_LeakyReLU(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_LeakyReLU(symbol)" args -> IO SymbolHandle+_backward_LeakyReLU name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LeakyReLU"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Crop(symbol)" =+     '[ '("num_args", AttrReq Int), '("offset", AttrOpt [Int]),+        '("h_w", AttrOpt [Int]), '("center_crop", AttrOpt Bool),+        '("data", AttrOpt [SymbolHandle])]++_Crop ::+      forall args . Fullfilled "_Crop(symbol)" args =>+        String -> ArgsHMap "_Crop(symbol)" args -> IO SymbolHandle+_Crop name args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]),+               ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]),+               ("center_crop",) . showValue <$>+                 (args !? #center_crop :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "Crop"+         sym <- if hasKey args #num_args then+                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals+                  else+                  mxSymbolCreateAtomicSymbol (fromOpHandle op)+                    ("num_args" : scalarkeys)+                    (showValue (length array) : scalarvals)+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_backward_Crop(symbol)" = '[]++_backward_Crop ::+               forall args . Fullfilled "_backward_Crop(symbol)" args =>+                 String -> ArgsHMap "_backward_Crop(symbol)" args -> IO SymbolHandle+_backward_Crop name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Crop"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_ROIPooling(symbol)" =+     '[ '("pooled_size", AttrReq [Int]),+        '("spatial_scale", AttrReq Float), '("data", AttrOpt SymbolHandle),+        '("rois", AttrOpt SymbolHandle)]++_ROIPooling ::+            forall args . Fullfilled "_ROIPooling(symbol)" args =>+              String -> ArgsHMap "_ROIPooling(symbol)" args -> IO SymbolHandle+_ROIPooling name args+  = let scalarArgs+          = catMaybes+              [("pooled_size",) . showValue <$>+                 (args !? #pooled_size :: Maybe [Int]),+               ("spatial_scale",) . showValue <$>+                 (args !? #spatial_scale :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ROIPooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_ROIPooling(symbol)" = '[]++_backward_ROIPooling ::+                     forall args . Fullfilled "_backward_ROIPooling(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_ROIPooling(symbol)" args -> IO SymbolHandle+_backward_ROIPooling name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_ROIPooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SequenceLast(symbol)" =+     '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int),+        '("data", AttrOpt SymbolHandle),+        '("sequence_length", AttrOpt SymbolHandle)]++_SequenceLast ::+              forall args . Fullfilled "_SequenceLast(symbol)" args =>+                String -> ArgsHMap "_SequenceLast(symbol)" args -> IO SymbolHandle+_SequenceLast name args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceLast"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SequenceLast(symbol)" = '[]++_backward_SequenceLast ::+                       forall args . Fullfilled "_backward_SequenceLast(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_SequenceLast(symbol)" args -> IO SymbolHandle+_backward_SequenceLast name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceLast"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_CrossDeviceCopy(symbol)" = '[]++_CrossDeviceCopy ::+                 forall args . Fullfilled "_CrossDeviceCopy(symbol)" args =>+                   String ->+                     ArgsHMap "_CrossDeviceCopy(symbol)" args -> IO SymbolHandle+_CrossDeviceCopy name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_CrossDeviceCopy"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward__CrossDeviceCopy(symbol)" =+     '[]++_backward__CrossDeviceCopy ::+                           forall args .+                             Fullfilled "_backward__CrossDeviceCopy(symbol)" args =>+                             String ->+                               ArgsHMap "_backward__CrossDeviceCopy(symbol)" args ->+                                 IO SymbolHandle+_backward__CrossDeviceCopy name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__CrossDeviceCopy"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SpatialTransformer(symbol)" =+     '[ '("target_shape", AttrOpt [Int]),+        '("transform_type", AttrReq (EnumType '["affine"])),+        '("sampler_type", AttrReq (EnumType '["bilinear"])),+        '("data", AttrOpt SymbolHandle), '("loc", AttrOpt SymbolHandle)]++_SpatialTransformer ::+                    forall args . Fullfilled "_SpatialTransformer(symbol)" args =>+                      String ->+                        ArgsHMap "_SpatialTransformer(symbol)" args -> IO SymbolHandle+_SpatialTransformer name args+  = let scalarArgs+          = catMaybes+              [("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("transform_type",) . showValue <$>+                 (args !? #transform_type :: Maybe (EnumType '["affine"])),+               ("sampler_type",) . showValue <$>+                 (args !? #sampler_type :: Maybe (EnumType '["bilinear"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("loc",) <$> (args !? #loc :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SpatialTransformer"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SpatialTransformer(symbol)"+     = '[]++_backward_SpatialTransformer ::+                             forall args .+                               Fullfilled "_backward_SpatialTransformer(symbol)" args =>+                               String ->+                                 ArgsHMap "_backward_SpatialTransformer(symbol)" args ->+                                   IO SymbolHandle+_backward_SpatialTransformer name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SpatialTransformer"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SwapAxis(symbol)" = '[]++_backward_SwapAxis ::+                   forall args . Fullfilled "_backward_SwapAxis(symbol)" args =>+                     String ->+                       ArgsHMap "_backward_SwapAxis(symbol)" args -> IO SymbolHandle+_backward_SwapAxis name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SwapAxis"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_L2Normalization(symbol)" =+     '[ '("eps", AttrOpt Float),+        '("mode", AttrOpt (EnumType '["channel", "instance", "spatial"])),+        '("data", AttrOpt SymbolHandle)]++_L2Normalization ::+                 forall args . Fullfilled "_L2Normalization(symbol)" args =>+                   String ->+                     ArgsHMap "_L2Normalization(symbol)" args -> IO SymbolHandle+_L2Normalization name args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["channel", "instance", "spatial"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "L2Normalization"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_L2Normalization(symbol)" =+     '[]++_backward_L2Normalization ::+                          forall args .+                            Fullfilled "_backward_L2Normalization(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_L2Normalization(symbol)" args ->+                                IO SymbolHandle+_backward_L2Normalization name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_L2Normalization"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Correlation(symbol)" =+     '[ '("kernel_size", AttrOpt Int),+        '("max_displacement", AttrOpt Int), '("stride1", AttrOpt Int),+        '("stride2", AttrOpt Int), '("pad_size", AttrOpt Int),+        '("is_multiply", AttrOpt Bool), '("data1", AttrOpt SymbolHandle),+        '("data2", AttrOpt SymbolHandle)]++_Correlation ::+             forall args . Fullfilled "_Correlation(symbol)" args =>+               String -> ArgsHMap "_Correlation(symbol)" args -> IO SymbolHandle+_Correlation name args+  = let scalarArgs+          = catMaybes+              [("kernel_size",) . showValue <$>+                 (args !? #kernel_size :: Maybe Int),+               ("max_displacement",) . showValue <$>+                 (args !? #max_displacement :: Maybe Int),+               ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int),+               ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int),+               ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int),+               ("is_multiply",) . showValue <$>+                 (args !? #is_multiply :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data1",) <$> (args !? #data1 :: Maybe SymbolHandle),+               ("data2",) <$> (args !? #data2 :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Correlation"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Correlation(symbol)" = '[]++_backward_Correlation ::+                      forall args . Fullfilled "_backward_Correlation(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_Correlation(symbol)" args -> IO SymbolHandle+_backward_Correlation name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Correlation"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward_IdentityAttachKLSparseReg(symbol)" = '[]++_backward_IdentityAttachKLSparseReg ::+                                    forall args .+                                      Fullfilled "_backward_IdentityAttachKLSparseReg(symbol)"+                                        args =>+                                      String ->+                                        ArgsHMap "_backward_IdentityAttachKLSparseReg(symbol)" args+                                          -> IO SymbolHandle+_backward_IdentityAttachKLSparseReg name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_MakeLoss(symbol)" =+     '[ '("grad_scale", AttrOpt Float),+        '("valid_thresh", AttrOpt Float),+        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),+        '("data", AttrOpt SymbolHandle)]++_MakeLoss ::+          forall args . Fullfilled "_MakeLoss(symbol)" args =>+            String -> ArgsHMap "_MakeLoss(symbol)" args -> IO SymbolHandle+_MakeLoss name args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float),+               ("valid_thresh",) . showValue <$>+                 (args !? #valid_thresh :: Maybe Float),+               ("normalization",) . showValue <$>+                 (args !? #normalization ::+                    Maybe (EnumType '["batch", "null", "valid"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "MakeLoss"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_MakeLoss(symbol)" = '[]++_backward_MakeLoss ::+                   forall args . Fullfilled "_backward_MakeLoss(symbol)" args =>+                     String ->+                       ArgsHMap "_backward_MakeLoss(symbol)" args -> IO SymbolHandle+_backward_MakeLoss name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_MakeLoss"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SliceChannel(symbol)" = '[]++_backward_SliceChannel ::+                       forall args . Fullfilled "_backward_SliceChannel(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_SliceChannel(symbol)" args -> IO SymbolHandle+_backward_SliceChannel name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SliceChannel"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_RNN(symbol)" =+     '[ '("state_size", AttrReq Int), '("num_layers", AttrReq Int),+        '("bidirectional", AttrOpt Bool),+        '("mode",+          AttrReq (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),+        '("p", AttrOpt Float), '("state_outputs", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle),+        '("parameters", AttrOpt SymbolHandle),+        '("state", AttrOpt SymbolHandle),+        '("state_cell", AttrOpt SymbolHandle)]++_RNN ::+     forall args . Fullfilled "_RNN(symbol)" args =>+       String -> ArgsHMap "_RNN(symbol)" args -> IO SymbolHandle+_RNN name args+  = let scalarArgs+          = catMaybes+              [("state_size",) . showValue <$>+                 (args !? #state_size :: Maybe Int),+               ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int),+               ("bidirectional",) . showValue <$>+                 (args !? #bidirectional :: Maybe Bool),+               ("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),+               ("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("state_outputs",) . showValue <$>+                 (args !? #state_outputs :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("parameters",) <$> (args !? #parameters :: Maybe SymbolHandle),+               ("state",) <$> (args !? #state :: Maybe SymbolHandle),+               ("state_cell",) <$> (args !? #state_cell :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "RNN"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_RNN(symbol)" = '[]++_backward_RNN ::+              forall args . Fullfilled "_backward_RNN(symbol)" args =>+                String -> ArgsHMap "_backward_RNN(symbol)" args -> IO SymbolHandle+_backward_RNN name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_RNN"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Pooling_v1(symbol)" =+     '[ '("kernel", AttrOpt [Int]),+        '("pool_type", AttrOpt (EnumType '["avg", "max", "sum"])),+        '("global_pool", AttrOpt Bool),+        '("pooling_convention", AttrOpt (EnumType '["full", "valid"])),+        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("data", AttrOpt SymbolHandle)]++_Pooling_v1 ::+            forall args . Fullfilled "_Pooling_v1(symbol)" args =>+              String -> ArgsHMap "_Pooling_v1(symbol)" args -> IO SymbolHandle+_Pooling_v1 name args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("pool_type",) . showValue <$>+                 (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])),+               ("global_pool",) . showValue <$>+                 (args !? #global_pool :: Maybe Bool),+               ("pooling_convention",) . showValue <$>+                 (args !? #pooling_convention ::+                    Maybe (EnumType '["full", "valid"])),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pooling_v1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Pooling_v1(symbol)" = '[]++_backward_Pooling_v1 ::+                     forall args . Fullfilled "_backward_Pooling_v1(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_Pooling_v1(symbol)" args -> IO SymbolHandle+_backward_Pooling_v1 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pooling_v1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_BatchNorm_v1(symbol)" = '[]++_backward_BatchNorm_v1 ::+                       forall args . Fullfilled "_backward_BatchNorm_v1(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_BatchNorm_v1(symbol)" args -> IO SymbolHandle+_backward_BatchNorm_v1 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BatchNorm_v1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SequenceMask(symbol)" =+     '[ '("use_sequence_length", AttrOpt Bool),+        '("value", AttrOpt Float), '("axis", AttrOpt Int),+        '("data", AttrOpt SymbolHandle),+        '("sequence_length", AttrOpt SymbolHandle)]++_SequenceMask ::+              forall args . Fullfilled "_SequenceMask(symbol)" args =>+                String -> ArgsHMap "_SequenceMask(symbol)" args -> IO SymbolHandle+_SequenceMask name args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool),+               ("value",) . showValue <$> (args !? #value :: Maybe Float),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceMask"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SequenceMask(symbol)" = '[]++_backward_SequenceMask ::+                       forall args . Fullfilled "_backward_SequenceMask(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_SequenceMask(symbol)" args -> IO SymbolHandle+_backward_SequenceMask name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceMask"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_set_value(symbol)" =+     '[ '("src", AttrOpt Float)]++_set_value ::+           forall args . Fullfilled "_set_value(symbol)" args =>+             String -> ArgsHMap "_set_value(symbol)" args -> IO SymbolHandle+_set_value name args+  = let scalarArgs+          = catMaybes+              [("src",) . showValue <$> (args !? #src :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_set_value"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_imdecode(symbol)" =+     '[ '("index", AttrOpt Int), '("x0", AttrOpt Int),+        '("y0", AttrOpt Int), '("x1", AttrOpt Int), '("y1", AttrOpt Int),+        '("c", AttrOpt Int), '("size", AttrOpt Int),+        '("mean", AttrOpt SymbolHandle)]++_imdecode ::+          forall args . Fullfilled "_imdecode(symbol)" args =>+            String -> ArgsHMap "_imdecode(symbol)" args -> IO SymbolHandle+_imdecode name args+  = let scalarArgs+          = catMaybes+              [("index",) . showValue <$> (args !? #index :: Maybe Int),+               ("x0",) . showValue <$> (args !? #x0 :: Maybe Int),+               ("y0",) . showValue <$> (args !? #y0 :: Maybe Int),+               ("x1",) . showValue <$> (args !? #x1 :: Maybe Int),+               ("y1",) . showValue <$> (args !? #y1 :: Maybe Int),+               ("c",) . showValue <$> (args !? #c :: Maybe Int),+               ("size",) . showValue <$> (args !? #size :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("mean",) <$> (args !? #mean :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_imdecode"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym
+ ops/1.4/MXNet/Base/Operators/NDArray.hs view
@@ -0,0 +1,21107 @@+module MXNet.Base.Operators.NDArray where+import MXNet.Base.Raw+import MXNet.Base.Spec.Operator+import MXNet.Base.Spec.HMap+import Data.Maybe (catMaybes, fromMaybe)++type instance ParameterList "_CuDNNBatchNorm(ndarray)" =+     '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float),+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),+        '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int),+        '("cudnn_off", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),+        '("gamma", AttrOpt NDArrayHandle),+        '("beta", AttrOpt NDArrayHandle),+        '("moving_mean", AttrOpt NDArrayHandle),+        '("moving_var", AttrOpt NDArrayHandle)]++_CuDNNBatchNorm ::+                forall args . Fullfilled "_CuDNNBatchNorm(ndarray)" args =>+                  ArgsHMap "_CuDNNBatchNorm(ndarray)" args -> IO [NDArrayHandle]+_CuDNNBatchNorm args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),+               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),+               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "CuDNNBatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_CuDNNBatchNorm_upd ::+                    forall args . Fullfilled "_CuDNNBatchNorm(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_CuDNNBatchNorm(ndarray)" args -> IO ()+_CuDNNBatchNorm_upd outputs args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),+               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),+               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "CuDNNBatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_CuDNNBatchNorm(ndarray)" =+     '[]++_backward_CuDNNBatchNorm ::+                         forall args .+                           Fullfilled "_backward_CuDNNBatchNorm(ndarray)" args =>+                           ArgsHMap "_backward_CuDNNBatchNorm(ndarray)" args ->+                             IO [NDArrayHandle]+_backward_CuDNNBatchNorm args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_CuDNNBatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_CuDNNBatchNorm_upd ::+                             forall args .+                               Fullfilled "_backward_CuDNNBatchNorm(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_backward_CuDNNBatchNorm(ndarray)" args -> IO ()+_backward_CuDNNBatchNorm_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_CuDNNBatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_sample_multinomial(ndarray)" =+     '[ '("shape", AttrOpt [Int]), '("get_prob", AttrOpt Bool),+        '("dtype",+          AttrOpt+            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),+        '("data", AttrOpt NDArrayHandle)]++_sample_multinomial ::+                    forall args . Fullfilled "_sample_multinomial(ndarray)" args =>+                      ArgsHMap "_sample_multinomial(ndarray)" args -> IO [NDArrayHandle]+_sample_multinomial args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_multinomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sample_multinomial_upd ::+                        forall args . Fullfilled "_sample_multinomial(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_sample_multinomial(ndarray)" args -> IO ()+_sample_multinomial_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_multinomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_sample_multinomial(ndarray)"+     = '[]++_backward_sample_multinomial ::+                             forall args .+                               Fullfilled "_backward_sample_multinomial(ndarray)" args =>+                               ArgsHMap "_backward_sample_multinomial(ndarray)" args ->+                                 IO [NDArrayHandle]+_backward_sample_multinomial args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sample_multinomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_sample_multinomial_upd ::+                                 forall args .+                                   Fullfilled "_backward_sample_multinomial(ndarray)" args =>+                                   [NDArrayHandle] ->+                                     ArgsHMap "_backward_sample_multinomial(ndarray)" args -> IO ()+_backward_sample_multinomial_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sample_multinomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_sample_uniform(ndarray)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("low", AttrOpt NDArrayHandle), '("high", AttrOpt NDArrayHandle)]++_sample_uniform ::+                forall args . Fullfilled "_sample_uniform(ndarray)" args =>+                  ArgsHMap "_sample_uniform(ndarray)" args -> IO [NDArrayHandle]+_sample_uniform args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("low",) <$> (args !? #low :: Maybe NDArrayHandle),+               ("high",) <$> (args !? #high :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_uniform"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sample_uniform_upd ::+                    forall args . Fullfilled "_sample_uniform(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_sample_uniform(ndarray)" args -> IO ()+_sample_uniform_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("low",) <$> (args !? #low :: Maybe NDArrayHandle),+               ("high",) <$> (args !? #high :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_uniform"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_sample_normal(ndarray)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("mu", AttrOpt NDArrayHandle), '("sigma", AttrOpt NDArrayHandle)]++_sample_normal ::+               forall args . Fullfilled "_sample_normal(ndarray)" args =>+                 ArgsHMap "_sample_normal(ndarray)" args -> IO [NDArrayHandle]+_sample_normal args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle),+               ("sigma",) <$> (args !? #sigma :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_normal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sample_normal_upd ::+                   forall args . Fullfilled "_sample_normal(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_sample_normal(ndarray)" args -> IO ()+_sample_normal_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle),+               ("sigma",) <$> (args !? #sigma :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_normal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_sample_gamma(ndarray)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("alpha", AttrOpt NDArrayHandle),+        '("beta", AttrOpt NDArrayHandle)]++_sample_gamma ::+              forall args . Fullfilled "_sample_gamma(ndarray)" args =>+                ArgsHMap "_sample_gamma(ndarray)" args -> IO [NDArrayHandle]+_sample_gamma args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_gamma"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sample_gamma_upd ::+                  forall args . Fullfilled "_sample_gamma(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_sample_gamma(ndarray)" args -> IO ()+_sample_gamma_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_gamma"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_sample_exponential(ndarray)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("lam", AttrOpt NDArrayHandle)]++_sample_exponential ::+                    forall args . Fullfilled "_sample_exponential(ndarray)" args =>+                      ArgsHMap "_sample_exponential(ndarray)" args -> IO [NDArrayHandle]+_sample_exponential args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_exponential"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sample_exponential_upd ::+                        forall args . Fullfilled "_sample_exponential(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_sample_exponential(ndarray)" args -> IO ()+_sample_exponential_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_exponential"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_sample_poisson(ndarray)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("lam", AttrOpt NDArrayHandle)]++_sample_poisson ::+                forall args . Fullfilled "_sample_poisson(ndarray)" args =>+                  ArgsHMap "_sample_poisson(ndarray)" args -> IO [NDArrayHandle]+_sample_poisson args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_poisson"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sample_poisson_upd ::+                    forall args . Fullfilled "_sample_poisson(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_sample_poisson(ndarray)" args -> IO ()+_sample_poisson_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_poisson"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_sample_negative_binomial(ndarray)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("k", AttrOpt NDArrayHandle), '("p", AttrOpt NDArrayHandle)]++_sample_negative_binomial ::+                          forall args .+                            Fullfilled "_sample_negative_binomial(ndarray)" args =>+                            ArgsHMap "_sample_negative_binomial(ndarray)" args ->+                              IO [NDArrayHandle]+_sample_negative_binomial args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("k",) <$> (args !? #k :: Maybe NDArrayHandle),+               ("p",) <$> (args !? #p :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_negative_binomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sample_negative_binomial_upd ::+                              forall args .+                                Fullfilled "_sample_negative_binomial(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_sample_negative_binomial(ndarray)" args -> IO ()+_sample_negative_binomial_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("k",) <$> (args !? #k :: Maybe NDArrayHandle),+               ("p",) <$> (args !? #p :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_negative_binomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_sample_generalized_negative_binomial(ndarray)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("mu", AttrOpt NDArrayHandle), '("alpha", AttrOpt NDArrayHandle)]++_sample_generalized_negative_binomial ::+                                      forall args .+                                        Fullfilled "_sample_generalized_negative_binomial(ndarray)"+                                          args =>+                                        ArgsHMap "_sample_generalized_negative_binomial(ndarray)"+                                          args+                                          -> IO [NDArrayHandle]+_sample_generalized_negative_binomial args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle),+               ("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_generalized_negative_binomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sample_generalized_negative_binomial_upd ::+                                          forall args .+                                            Fullfilled+                                              "_sample_generalized_negative_binomial(ndarray)"+                                              args =>+                                            [NDArrayHandle] ->+                                              ArgsHMap+                                                "_sample_generalized_negative_binomial(ndarray)"+                                                args+                                                -> IO ()+_sample_generalized_negative_binomial_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle),+               ("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_generalized_negative_binomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_sample_unique_zipfian(ndarray)" =+     '[ '("range_max", AttrReq Int), '("shape", AttrOpt [Int])]++_sample_unique_zipfian ::+                       forall args . Fullfilled "_sample_unique_zipfian(ndarray)" args =>+                         ArgsHMap "_sample_unique_zipfian(ndarray)" args ->+                           IO [NDArrayHandle]+_sample_unique_zipfian args+  = let scalarArgs+          = catMaybes+              [("range_max",) . showValue <$> (args !? #range_max :: Maybe Int),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_unique_zipfian"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sample_unique_zipfian_upd ::+                           forall args . Fullfilled "_sample_unique_zipfian(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_sample_unique_zipfian(ndarray)" args -> IO ()+_sample_unique_zipfian_upd outputs args+  = let scalarArgs+          = catMaybes+              [("range_max",) . showValue <$> (args !? #range_max :: Maybe Int),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_unique_zipfian"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_uniform(ndarray)" =+     '[ '("low", AttrOpt Float), '("high", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_uniform ::+                forall args . Fullfilled "_random_uniform(ndarray)" args =>+                  ArgsHMap "_random_uniform(ndarray)" args -> IO [NDArrayHandle]+_random_uniform args+  = let scalarArgs+          = catMaybes+              [("low",) . showValue <$> (args !? #low :: Maybe Float),+               ("high",) . showValue <$> (args !? #high :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_uniform"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_uniform_upd ::+                    forall args . Fullfilled "_random_uniform(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_random_uniform(ndarray)" args -> IO ()+_random_uniform_upd outputs args+  = let scalarArgs+          = catMaybes+              [("low",) . showValue <$> (args !? #low :: Maybe Float),+               ("high",) . showValue <$> (args !? #high :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_uniform"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_normal(ndarray)" =+     '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_normal ::+               forall args . Fullfilled "_random_normal(ndarray)" args =>+                 ArgsHMap "_random_normal(ndarray)" args -> IO [NDArrayHandle]+_random_normal args+  = let scalarArgs+          = catMaybes+              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),+               ("scale",) . showValue <$> (args !? #scale :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_normal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_normal_upd ::+                   forall args . Fullfilled "_random_normal(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_random_normal(ndarray)" args -> IO ()+_random_normal_upd outputs args+  = let scalarArgs+          = catMaybes+              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),+               ("scale",) . showValue <$> (args !? #scale :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_normal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_gamma(ndarray)" =+     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_gamma ::+              forall args . Fullfilled "_random_gamma(ndarray)" args =>+                ArgsHMap "_random_gamma(ndarray)" args -> IO [NDArrayHandle]+_random_gamma args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_gamma"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_gamma_upd ::+                  forall args . Fullfilled "_random_gamma(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_random_gamma(ndarray)" args -> IO ()+_random_gamma_upd outputs args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_gamma"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_exponential(ndarray)" =+     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),+        '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_exponential ::+                    forall args . Fullfilled "_random_exponential(ndarray)" args =>+                      ArgsHMap "_random_exponential(ndarray)" args -> IO [NDArrayHandle]+_random_exponential args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_exponential"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_exponential_upd ::+                        forall args . Fullfilled "_random_exponential(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_random_exponential(ndarray)" args -> IO ()+_random_exponential_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_exponential"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_poisson(ndarray)" =+     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),+        '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_poisson ::+                forall args . Fullfilled "_random_poisson(ndarray)" args =>+                  ArgsHMap "_random_poisson(ndarray)" args -> IO [NDArrayHandle]+_random_poisson args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_poisson"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_poisson_upd ::+                    forall args . Fullfilled "_random_poisson(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_random_poisson(ndarray)" args -> IO ()+_random_poisson_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_poisson"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_negative_binomial(ndarray)" =+     '[ '("k", AttrOpt Int), '("p", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_negative_binomial ::+                          forall args .+                            Fullfilled "_random_negative_binomial(ndarray)" args =>+                            ArgsHMap "_random_negative_binomial(ndarray)" args ->+                              IO [NDArrayHandle]+_random_negative_binomial args+  = let scalarArgs+          = catMaybes+              [("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_negative_binomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_negative_binomial_upd ::+                              forall args .+                                Fullfilled "_random_negative_binomial(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_random_negative_binomial(ndarray)" args -> IO ()+_random_negative_binomial_upd outputs args+  = let scalarArgs+          = catMaybes+              [("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_negative_binomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_random_generalized_negative_binomial(ndarray)" =+     '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_generalized_negative_binomial ::+                                      forall args .+                                        Fullfilled "_random_generalized_negative_binomial(ndarray)"+                                          args =>+                                        ArgsHMap "_random_generalized_negative_binomial(ndarray)"+                                          args+                                          -> IO [NDArrayHandle]+_random_generalized_negative_binomial args+  = let scalarArgs+          = catMaybes+              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_generalized_negative_binomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_generalized_negative_binomial_upd ::+                                          forall args .+                                            Fullfilled+                                              "_random_generalized_negative_binomial(ndarray)"+                                              args =>+                                            [NDArrayHandle] ->+                                              ArgsHMap+                                                "_random_generalized_negative_binomial(ndarray)"+                                                args+                                                -> IO ()+_random_generalized_negative_binomial_upd outputs args+  = let scalarArgs+          = catMaybes+              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_generalized_negative_binomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_randint(ndarray)" =+     '[ '("low", AttrReq Int), '("high", AttrReq Int),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype", AttrOpt (EnumType '["None", "int32", "int64"]))]++_random_randint ::+                forall args . Fullfilled "_random_randint(ndarray)" args =>+                  ArgsHMap "_random_randint(ndarray)" args -> IO [NDArrayHandle]+_random_randint args+  = let scalarArgs+          = catMaybes+              [("low",) . showValue <$> (args !? #low :: Maybe Int),+               ("high",) . showValue <$> (args !? #high :: Maybe Int),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype :: Maybe (EnumType '["None", "int32", "int64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_randint"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_randint_upd ::+                    forall args . Fullfilled "_random_randint(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_random_randint(ndarray)" args -> IO ()+_random_randint_upd outputs args+  = let scalarArgs+          = catMaybes+              [("low",) . showValue <$> (args !? #low :: Maybe Int),+               ("high",) . showValue <$> (args !? #high :: Maybe Int),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype :: Maybe (EnumType '["None", "int32", "int64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_randint"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_uniform_like(ndarray)" =+     '[ '("low", AttrOpt Float), '("high", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle)]++_random_uniform_like ::+                     forall args . Fullfilled "_random_uniform_like(ndarray)" args =>+                       ArgsHMap "_random_uniform_like(ndarray)" args -> IO [NDArrayHandle]+_random_uniform_like args+  = let scalarArgs+          = catMaybes+              [("low",) . showValue <$> (args !? #low :: Maybe Float),+               ("high",) . showValue <$> (args !? #high :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_uniform_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_uniform_like_upd ::+                         forall args . Fullfilled "_random_uniform_like(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_random_uniform_like(ndarray)" args -> IO ()+_random_uniform_like_upd outputs args+  = let scalarArgs+          = catMaybes+              [("low",) . showValue <$> (args !? #low :: Maybe Float),+               ("high",) . showValue <$> (args !? #high :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_uniform_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_normal_like(ndarray)" =+     '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle)]++_random_normal_like ::+                    forall args . Fullfilled "_random_normal_like(ndarray)" args =>+                      ArgsHMap "_random_normal_like(ndarray)" args -> IO [NDArrayHandle]+_random_normal_like args+  = let scalarArgs+          = catMaybes+              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),+               ("scale",) . showValue <$> (args !? #scale :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_normal_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_normal_like_upd ::+                        forall args . Fullfilled "_random_normal_like(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_random_normal_like(ndarray)" args -> IO ()+_random_normal_like_upd outputs args+  = let scalarArgs+          = catMaybes+              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),+               ("scale",) . showValue <$> (args !? #scale :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_normal_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_gamma_like(ndarray)" =+     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle)]++_random_gamma_like ::+                   forall args . Fullfilled "_random_gamma_like(ndarray)" args =>+                     ArgsHMap "_random_gamma_like(ndarray)" args -> IO [NDArrayHandle]+_random_gamma_like args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_gamma_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_gamma_like_upd ::+                       forall args . Fullfilled "_random_gamma_like(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_random_gamma_like(ndarray)" args -> IO ()+_random_gamma_like_upd outputs args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_gamma_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_exponential_like(ndarray)" =+     '[ '("lam", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_random_exponential_like ::+                         forall args .+                           Fullfilled "_random_exponential_like(ndarray)" args =>+                           ArgsHMap "_random_exponential_like(ndarray)" args ->+                             IO [NDArrayHandle]+_random_exponential_like args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_exponential_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_exponential_like_upd ::+                             forall args .+                               Fullfilled "_random_exponential_like(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_random_exponential_like(ndarray)" args -> IO ()+_random_exponential_like_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_exponential_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_poisson_like(ndarray)" =+     '[ '("lam", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_random_poisson_like ::+                     forall args . Fullfilled "_random_poisson_like(ndarray)" args =>+                       ArgsHMap "_random_poisson_like(ndarray)" args -> IO [NDArrayHandle]+_random_poisson_like args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_poisson_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_poisson_like_upd ::+                         forall args . Fullfilled "_random_poisson_like(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_random_poisson_like(ndarray)" args -> IO ()+_random_poisson_like_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_poisson_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_random_negative_binomial_like(ndarray)" =+     '[ '("k", AttrOpt Int), '("p", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle)]++_random_negative_binomial_like ::+                               forall args .+                                 Fullfilled "_random_negative_binomial_like(ndarray)" args =>+                                 ArgsHMap "_random_negative_binomial_like(ndarray)" args ->+                                   IO [NDArrayHandle]+_random_negative_binomial_like args+  = let scalarArgs+          = catMaybes+              [("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("p",) . showValue <$> (args !? #p :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_negative_binomial_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_negative_binomial_like_upd ::+                                   forall args .+                                     Fullfilled "_random_negative_binomial_like(ndarray)" args =>+                                     [NDArrayHandle] ->+                                       ArgsHMap "_random_negative_binomial_like(ndarray)" args ->+                                         IO ()+_random_negative_binomial_like_upd outputs args+  = let scalarArgs+          = catMaybes+              [("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("p",) . showValue <$> (args !? #p :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_negative_binomial_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_random_generalized_negative_binomial_like(ndarray)"+     =+     '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle)]++_random_generalized_negative_binomial_like ::+                                           forall args .+                                             Fullfilled+                                               "_random_generalized_negative_binomial_like(ndarray)"+                                               args =>+                                             ArgsHMap+                                               "_random_generalized_negative_binomial_like(ndarray)"+                                               args+                                               -> IO [NDArrayHandle]+_random_generalized_negative_binomial_like args+  = let scalarArgs+          = catMaybes+              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_generalized_negative_binomial_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_generalized_negative_binomial_like_upd ::+                                               forall args .+                                                 Fullfilled+                                                   "_random_generalized_negative_binomial_like(ndarray)"+                                                   args =>+                                                 [NDArrayHandle] ->+                                                   ArgsHMap+                                                     "_random_generalized_negative_binomial_like(ndarray)"+                                                     args+                                                     -> IO ()+_random_generalized_negative_binomial_like_upd outputs args+  = let scalarArgs+          = catMaybes+              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_generalized_negative_binomial_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_shuffle(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_shuffle ::+         forall args . Fullfilled "_shuffle(ndarray)" args =>+           ArgsHMap "_shuffle(ndarray)" args -> IO [NDArrayHandle]+_shuffle args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_shuffle"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_shuffle_upd ::+             forall args . Fullfilled "_shuffle(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "_shuffle(ndarray)" args -> IO ()+_shuffle_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_shuffle"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Custom(ndarray)" = '[]++_backward_Custom ::+                 forall args . Fullfilled "_backward_Custom(ndarray)" args =>+                   ArgsHMap "_backward_Custom(ndarray)" args -> IO [NDArrayHandle]+_backward_Custom args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Custom"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Custom_upd ::+                     forall args . Fullfilled "_backward_Custom(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_backward_Custom(ndarray)" args -> IO ()+_backward_Custom_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Custom"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_power(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_power ::+                forall args . Fullfilled "broadcast_power(ndarray)" args =>+                  ArgsHMap "broadcast_power(ndarray)" args -> IO [NDArrayHandle]+broadcast_power args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_power"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_power_upd ::+                    forall args . Fullfilled "broadcast_power(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "broadcast_power(ndarray)" args -> IO ()+broadcast_power_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_power"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_broadcast_power(ndarray)" =+     '[]++_backward_broadcast_power ::+                          forall args .+                            Fullfilled "_backward_broadcast_power(ndarray)" args =>+                            ArgsHMap "_backward_broadcast_power(ndarray)" args ->+                              IO [NDArrayHandle]+_backward_broadcast_power args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_power"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_broadcast_power_upd ::+                              forall args .+                                Fullfilled "_backward_broadcast_power(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_backward_broadcast_power(ndarray)" args -> IO ()+_backward_broadcast_power_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_power"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_maximum(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_maximum ::+                  forall args . Fullfilled "broadcast_maximum(ndarray)" args =>+                    ArgsHMap "broadcast_maximum(ndarray)" args -> IO [NDArrayHandle]+broadcast_maximum args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_maximum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_maximum_upd ::+                      forall args . Fullfilled "broadcast_maximum(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "broadcast_maximum(ndarray)" args -> IO ()+broadcast_maximum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_maximum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_broadcast_maximum(ndarray)"+     = '[]++_backward_broadcast_maximum ::+                            forall args .+                              Fullfilled "_backward_broadcast_maximum(ndarray)" args =>+                              ArgsHMap "_backward_broadcast_maximum(ndarray)" args ->+                                IO [NDArrayHandle]+_backward_broadcast_maximum args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_maximum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_broadcast_maximum_upd ::+                                forall args .+                                  Fullfilled "_backward_broadcast_maximum(ndarray)" args =>+                                  [NDArrayHandle] ->+                                    ArgsHMap "_backward_broadcast_maximum(ndarray)" args -> IO ()+_backward_broadcast_maximum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_maximum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_minimum(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_minimum ::+                  forall args . Fullfilled "broadcast_minimum(ndarray)" args =>+                    ArgsHMap "broadcast_minimum(ndarray)" args -> IO [NDArrayHandle]+broadcast_minimum args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_minimum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_minimum_upd ::+                      forall args . Fullfilled "broadcast_minimum(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "broadcast_minimum(ndarray)" args -> IO ()+broadcast_minimum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_minimum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_broadcast_minimum(ndarray)"+     = '[]++_backward_broadcast_minimum ::+                            forall args .+                              Fullfilled "_backward_broadcast_minimum(ndarray)" args =>+                              ArgsHMap "_backward_broadcast_minimum(ndarray)" args ->+                                IO [NDArrayHandle]+_backward_broadcast_minimum args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_minimum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_broadcast_minimum_upd ::+                                forall args .+                                  Fullfilled "_backward_broadcast_minimum(ndarray)" args =>+                                  [NDArrayHandle] ->+                                    ArgsHMap "_backward_broadcast_minimum(ndarray)" args -> IO ()+_backward_broadcast_minimum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_minimum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_hypot(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_hypot ::+                forall args . Fullfilled "broadcast_hypot(ndarray)" args =>+                  ArgsHMap "broadcast_hypot(ndarray)" args -> IO [NDArrayHandle]+broadcast_hypot args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_hypot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_hypot_upd ::+                    forall args . Fullfilled "broadcast_hypot(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "broadcast_hypot(ndarray)" args -> IO ()+broadcast_hypot_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_hypot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_broadcast_hypot(ndarray)" =+     '[]++_backward_broadcast_hypot ::+                          forall args .+                            Fullfilled "_backward_broadcast_hypot(ndarray)" args =>+                            ArgsHMap "_backward_broadcast_hypot(ndarray)" args ->+                              IO [NDArrayHandle]+_backward_broadcast_hypot args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_hypot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_broadcast_hypot_upd ::+                              forall args .+                                Fullfilled "_backward_broadcast_hypot(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_backward_broadcast_hypot(ndarray)" args -> IO ()+_backward_broadcast_hypot_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_hypot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_equal(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_equal ::+       forall args . Fullfilled "_equal(ndarray)" args =>+         ArgsHMap "_equal(ndarray)" args -> IO [NDArrayHandle]+_equal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_equal_upd ::+           forall args . Fullfilled "_equal(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "_equal(ndarray)" args -> IO ()+_equal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_not_equal(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_not_equal ::+           forall args . Fullfilled "_not_equal(ndarray)" args =>+             ArgsHMap "_not_equal(ndarray)" args -> IO [NDArrayHandle]+_not_equal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_not_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_not_equal_upd ::+               forall args . Fullfilled "_not_equal(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "_not_equal(ndarray)" args -> IO ()+_not_equal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_not_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_greater(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_greater ::+         forall args . Fullfilled "_greater(ndarray)" args =>+           ArgsHMap "_greater(ndarray)" args -> IO [NDArrayHandle]+_greater args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_greater_upd ::+             forall args . Fullfilled "_greater(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "_greater(ndarray)" args -> IO ()+_greater_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_greater_equal(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_greater_equal ::+               forall args . Fullfilled "_greater_equal(ndarray)" args =>+                 ArgsHMap "_greater_equal(ndarray)" args -> IO [NDArrayHandle]+_greater_equal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_greater_equal_upd ::+                   forall args . Fullfilled "_greater_equal(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_greater_equal(ndarray)" args -> IO ()+_greater_equal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_lesser(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_lesser ::+        forall args . Fullfilled "_lesser(ndarray)" args =>+          ArgsHMap "_lesser(ndarray)" args -> IO [NDArrayHandle]+_lesser args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_lesser_upd ::+            forall args . Fullfilled "_lesser(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "_lesser(ndarray)" args -> IO ()+_lesser_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_lesser_equal(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_lesser_equal ::+              forall args . Fullfilled "_lesser_equal(ndarray)" args =>+                ArgsHMap "_lesser_equal(ndarray)" args -> IO [NDArrayHandle]+_lesser_equal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_lesser_equal_upd ::+                  forall args . Fullfilled "_lesser_equal(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_lesser_equal(ndarray)" args -> IO ()+_lesser_equal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_logical_and(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_logical_and ::+             forall args . Fullfilled "_logical_and(ndarray)" args =>+               ArgsHMap "_logical_and(ndarray)" args -> IO [NDArrayHandle]+_logical_and args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_and"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_logical_and_upd ::+                 forall args . Fullfilled "_logical_and(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_logical_and(ndarray)" args -> IO ()+_logical_and_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_and"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_logical_or(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_logical_or ::+            forall args . Fullfilled "_logical_or(ndarray)" args =>+              ArgsHMap "_logical_or(ndarray)" args -> IO [NDArrayHandle]+_logical_or args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_or"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_logical_or_upd ::+                forall args . Fullfilled "_logical_or(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_logical_or(ndarray)" args -> IO ()+_logical_or_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_or"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_logical_xor(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_logical_xor ::+             forall args . Fullfilled "_logical_xor(ndarray)" args =>+               ArgsHMap "_logical_xor(ndarray)" args -> IO [NDArrayHandle]+_logical_xor args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_xor"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_logical_xor_upd ::+                 forall args . Fullfilled "_logical_xor(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_logical_xor(ndarray)" args -> IO ()+_logical_xor_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_xor"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_power(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_power ::+       forall args . Fullfilled "_power(ndarray)" args =>+         ArgsHMap "_power(ndarray)" args -> IO [NDArrayHandle]+_power args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_power"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_power_upd ::+           forall args . Fullfilled "_power(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "_power(ndarray)" args -> IO ()+_power_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_power"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_power(ndarray)" = '[]++_backward_power ::+                forall args . Fullfilled "_backward_power(ndarray)" args =>+                  ArgsHMap "_backward_power(ndarray)" args -> IO [NDArrayHandle]+_backward_power args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_power"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_power_upd ::+                    forall args . Fullfilled "_backward_power(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_power(ndarray)" args -> IO ()+_backward_power_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_power"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_maximum(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_maximum ::+         forall args . Fullfilled "_maximum(ndarray)" args =>+           ArgsHMap "_maximum(ndarray)" args -> IO [NDArrayHandle]+_maximum args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_maximum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_maximum_upd ::+             forall args . Fullfilled "_maximum(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "_maximum(ndarray)" args -> IO ()+_maximum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_maximum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_maximum(ndarray)" = '[]++_backward_maximum ::+                  forall args . Fullfilled "_backward_maximum(ndarray)" args =>+                    ArgsHMap "_backward_maximum(ndarray)" args -> IO [NDArrayHandle]+_backward_maximum args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_maximum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_maximum_upd ::+                      forall args . Fullfilled "_backward_maximum(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_maximum(ndarray)" args -> IO ()+_backward_maximum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_maximum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_minimum(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_minimum ::+         forall args . Fullfilled "_minimum(ndarray)" args =>+           ArgsHMap "_minimum(ndarray)" args -> IO [NDArrayHandle]+_minimum args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minimum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_minimum_upd ::+             forall args . Fullfilled "_minimum(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "_minimum(ndarray)" args -> IO ()+_minimum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minimum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_minimum(ndarray)" = '[]++_backward_minimum ::+                  forall args . Fullfilled "_backward_minimum(ndarray)" args =>+                    ArgsHMap "_backward_minimum(ndarray)" args -> IO [NDArrayHandle]+_backward_minimum args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_minimum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_minimum_upd ::+                      forall args . Fullfilled "_backward_minimum(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_minimum(ndarray)" args -> IO ()+_backward_minimum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_minimum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_hypot(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_hypot ::+       forall args . Fullfilled "_hypot(ndarray)" args =>+         ArgsHMap "_hypot(ndarray)" args -> IO [NDArrayHandle]+_hypot args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_hypot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_hypot_upd ::+           forall args . Fullfilled "_hypot(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "_hypot(ndarray)" args -> IO ()+_hypot_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_hypot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_hypot(ndarray)" = '[]++_backward_hypot ::+                forall args . Fullfilled "_backward_hypot(ndarray)" args =>+                  ArgsHMap "_backward_hypot(ndarray)" args -> IO [NDArrayHandle]+_backward_hypot args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_hypot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_hypot_upd ::+                    forall args . Fullfilled "_backward_hypot(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_hypot(ndarray)" args -> IO ()+_backward_hypot_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_hypot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_square_sum(ndarray)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++_square_sum ::+            forall args . Fullfilled "_square_sum(ndarray)" args =>+              ArgsHMap "_square_sum(ndarray)" args -> IO [NDArrayHandle]+_square_sum args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_square_sum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_square_sum_upd ::+                forall args . Fullfilled "_square_sum(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_square_sum(ndarray)" args -> IO ()+_square_sum_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_square_sum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_square_sum(ndarray)" = '[]++_backward_square_sum ::+                     forall args . Fullfilled "_backward_square_sum(ndarray)" args =>+                       ArgsHMap "_backward_square_sum(ndarray)" args -> IO [NDArrayHandle]+_backward_square_sum args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_square_sum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_square_sum_upd ::+                         forall args . Fullfilled "_backward_square_sum(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_square_sum(ndarray)" args -> IO ()+_backward_square_sum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_square_sum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "add_n(ndarray)" =+     '[ '("args", AttrOpt [NDArrayHandle])]++add_n ::+      forall args . Fullfilled "add_n(ndarray)" args =>+        ArgsHMap "add_n(ndarray)" args -> IO [NDArrayHandle]+add_n args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "add_n"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        Nothing+         return listndarr++add_n_upd ::+          forall args . Fullfilled "add_n(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "add_n(ndarray)" args -> IO ()+add_n_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "add_n"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        (Just outputs)+         return ()++type instance ParameterList "_zeros_without_dtype(ndarray)" =+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype", AttrOpt Int)]++_zeros_without_dtype ::+                     forall args . Fullfilled "_zeros_without_dtype(ndarray)" args =>+                       ArgsHMap "_zeros_without_dtype(ndarray)" args -> IO [NDArrayHandle]+_zeros_without_dtype args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$> (args !? #dtype :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_zeros_without_dtype"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_zeros_without_dtype_upd ::+                         forall args . Fullfilled "_zeros_without_dtype(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_zeros_without_dtype(ndarray)" args -> IO ()+_zeros_without_dtype_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$> (args !? #dtype :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_zeros_without_dtype"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_zeros(ndarray)" =+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"]))]++_zeros ::+       forall args . Fullfilled "_zeros(ndarray)" args =>+         ArgsHMap "_zeros(ndarray)" args -> IO [NDArrayHandle]+_zeros args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_zeros"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_zeros_upd ::+           forall args . Fullfilled "_zeros(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "_zeros(ndarray)" args -> IO ()+_zeros_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_zeros"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_eye(ndarray)" =+     '[ '("_N", AttrReq Int), '("_M", AttrOpt Int), '("k", AttrOpt Int),+        '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"]))]++_eye ::+     forall args . Fullfilled "_eye(ndarray)" args =>+       ArgsHMap "_eye(ndarray)" args -> IO [NDArrayHandle]+_eye args+  = let scalarArgs+          = catMaybes+              [("_N",) . showValue <$> (args !? #_N :: Maybe Int),+               ("_M",) . showValue <$> (args !? #_M :: Maybe Int),+               ("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_eye"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_eye_upd ::+         forall args . Fullfilled "_eye(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "_eye(ndarray)" args -> IO ()+_eye_upd outputs args+  = let scalarArgs+          = catMaybes+              [("_N",) . showValue <$> (args !? #_N :: Maybe Int),+               ("_M",) . showValue <$> (args !? #_M :: Maybe Int),+               ("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_eye"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_ones(ndarray)" =+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"]))]++_ones ::+      forall args . Fullfilled "_ones(ndarray)" args =>+        ArgsHMap "_ones(ndarray)" args -> IO [NDArrayHandle]+_ones args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_ones"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_ones_upd ::+          forall args . Fullfilled "_ones(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "_ones(ndarray)" args -> IO ()+_ones_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_ones"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_full(ndarray)" =+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("value", AttrReq Double)]++_full ::+      forall args . Fullfilled "_full(ndarray)" args =>+        ArgsHMap "_full(ndarray)" args -> IO [NDArrayHandle]+_full args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"])),+               ("value",) . showValue <$> (args !? #value :: Maybe Double)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_full"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_full_upd ::+          forall args . Fullfilled "_full(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "_full(ndarray)" args -> IO ()+_full_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"])),+               ("value",) . showValue <$> (args !? #value :: Maybe Double)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_full"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_arange(ndarray)" =+     '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)),+        '("step", AttrOpt Double), '("repeat", AttrOpt Int),+        '("infer_range", AttrOpt Bool), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"]))]++_arange ::+        forall args . Fullfilled "_arange(ndarray)" args =>+          ArgsHMap "_arange(ndarray)" args -> IO [NDArrayHandle]+_arange args+  = let scalarArgs+          = catMaybes+              [("start",) . showValue <$> (args !? #start :: Maybe Double),+               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),+               ("step",) . showValue <$> (args !? #step :: Maybe Double),+               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),+               ("infer_range",) . showValue <$>+                 (args !? #infer_range :: Maybe Bool),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_arange"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_arange_upd ::+            forall args . Fullfilled "_arange(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "_arange(ndarray)" args -> IO ()+_arange_upd outputs args+  = let scalarArgs+          = catMaybes+              [("start",) . showValue <$> (args !? #start :: Maybe Double),+               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),+               ("step",) . showValue <$> (args !? #step :: Maybe Double),+               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),+               ("infer_range",) . showValue <$>+                 (args !? #infer_range :: Maybe Bool),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_arange"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "zeros_like(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++zeros_like ::+           forall args . Fullfilled "zeros_like(ndarray)" args =>+             ArgsHMap "zeros_like(ndarray)" args -> IO [NDArrayHandle]+zeros_like args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "zeros_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++zeros_like_upd ::+               forall args . Fullfilled "zeros_like(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "zeros_like(ndarray)" args -> IO ()+zeros_like_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "zeros_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "ones_like(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++ones_like ::+          forall args . Fullfilled "ones_like(ndarray)" args =>+            ArgsHMap "ones_like(ndarray)" args -> IO [NDArrayHandle]+ones_like args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ones_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++ones_like_upd ::+              forall args . Fullfilled "ones_like(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "ones_like(ndarray)" args -> IO ()+ones_like_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ones_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_add(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_add ::+              forall args . Fullfilled "broadcast_add(ndarray)" args =>+                ArgsHMap "broadcast_add(ndarray)" args -> IO [NDArrayHandle]+broadcast_add args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_add_upd ::+                  forall args . Fullfilled "broadcast_add(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "broadcast_add(ndarray)" args -> IO ()+broadcast_add_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_broadcast_add(ndarray)" =+     '[]++_backward_broadcast_add ::+                        forall args . Fullfilled "_backward_broadcast_add(ndarray)" args =>+                          ArgsHMap "_backward_broadcast_add(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_broadcast_add args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_broadcast_add_upd ::+                            forall args . Fullfilled "_backward_broadcast_add(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_broadcast_add(ndarray)" args -> IO ()+_backward_broadcast_add_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_sub(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_sub ::+              forall args . Fullfilled "broadcast_sub(ndarray)" args =>+                ArgsHMap "broadcast_sub(ndarray)" args -> IO [NDArrayHandle]+broadcast_sub args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_sub"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_sub_upd ::+                  forall args . Fullfilled "broadcast_sub(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "broadcast_sub(ndarray)" args -> IO ()+broadcast_sub_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_sub"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_broadcast_sub(ndarray)" =+     '[]++_backward_broadcast_sub ::+                        forall args . Fullfilled "_backward_broadcast_sub(ndarray)" args =>+                          ArgsHMap "_backward_broadcast_sub(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_broadcast_sub args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_sub"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_broadcast_sub_upd ::+                            forall args . Fullfilled "_backward_broadcast_sub(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_broadcast_sub(ndarray)" args -> IO ()+_backward_broadcast_sub_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_sub"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_mul(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_mul ::+              forall args . Fullfilled "broadcast_mul(ndarray)" args =>+                ArgsHMap "broadcast_mul(ndarray)" args -> IO [NDArrayHandle]+broadcast_mul args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_mul"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_mul_upd ::+                  forall args . Fullfilled "broadcast_mul(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "broadcast_mul(ndarray)" args -> IO ()+broadcast_mul_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_mul"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_broadcast_mul(ndarray)" =+     '[]++_backward_broadcast_mul ::+                        forall args . Fullfilled "_backward_broadcast_mul(ndarray)" args =>+                          ArgsHMap "_backward_broadcast_mul(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_broadcast_mul args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_mul"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_broadcast_mul_upd ::+                            forall args . Fullfilled "_backward_broadcast_mul(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_broadcast_mul(ndarray)" args -> IO ()+_backward_broadcast_mul_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_mul"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_div(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_div ::+              forall args . Fullfilled "broadcast_div(ndarray)" args =>+                ArgsHMap "broadcast_div(ndarray)" args -> IO [NDArrayHandle]+broadcast_div args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_div_upd ::+                  forall args . Fullfilled "broadcast_div(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "broadcast_div(ndarray)" args -> IO ()+broadcast_div_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_broadcast_div(ndarray)" =+     '[]++_backward_broadcast_div ::+                        forall args . Fullfilled "_backward_broadcast_div(ndarray)" args =>+                          ArgsHMap "_backward_broadcast_div(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_broadcast_div args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_broadcast_div_upd ::+                            forall args . Fullfilled "_backward_broadcast_div(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_broadcast_div(ndarray)" args -> IO ()+_backward_broadcast_div_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_mod(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_mod ::+              forall args . Fullfilled "broadcast_mod(ndarray)" args =>+                ArgsHMap "broadcast_mod(ndarray)" args -> IO [NDArrayHandle]+broadcast_mod args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_mod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_mod_upd ::+                  forall args . Fullfilled "broadcast_mod(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "broadcast_mod(ndarray)" args -> IO ()+broadcast_mod_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_mod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_broadcast_mod(ndarray)" =+     '[]++_backward_broadcast_mod ::+                        forall args . Fullfilled "_backward_broadcast_mod(ndarray)" args =>+                          ArgsHMap "_backward_broadcast_mod(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_broadcast_mod args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_mod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_broadcast_mod_upd ::+                            forall args . Fullfilled "_backward_broadcast_mod(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_broadcast_mod(ndarray)" args -> IO ()+_backward_broadcast_mod_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_mod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_gemm(ndarray)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("alpha", AttrOpt Double), '("beta", AttrOpt Double),+        '("axis", AttrOpt Int), '("_A", AttrOpt NDArrayHandle),+        '("_B", AttrOpt NDArrayHandle), '("_C", AttrOpt NDArrayHandle)]++_linalg_gemm ::+             forall args . Fullfilled "_linalg_gemm(ndarray)" args =>+               ArgsHMap "_linalg_gemm(ndarray)" args -> IO [NDArrayHandle]+_linalg_gemm args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Double),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),+               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle),+               ("_C",) <$> (args !? #_C :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gemm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_gemm_upd ::+                 forall args . Fullfilled "_linalg_gemm(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_linalg_gemm(ndarray)" args -> IO ()+_linalg_gemm_upd outputs args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Double),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),+               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle),+               ("_C",) <$> (args !? #_C :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gemm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_gemm(ndarray)" = '[]++_backward_linalg_gemm ::+                      forall args . Fullfilled "_backward_linalg_gemm(ndarray)" args =>+                        ArgsHMap "_backward_linalg_gemm(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_linalg_gemm args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gemm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_gemm_upd ::+                          forall args . Fullfilled "_backward_linalg_gemm(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_linalg_gemm(ndarray)" args -> IO ()+_backward_linalg_gemm_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gemm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_gemm2(ndarray)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("alpha", AttrOpt Double), '("axis", AttrOpt Int),+        '("_A", AttrOpt NDArrayHandle), '("_B", AttrOpt NDArrayHandle)]++_linalg_gemm2 ::+              forall args . Fullfilled "_linalg_gemm2(ndarray)" args =>+                ArgsHMap "_linalg_gemm2(ndarray)" args -> IO [NDArrayHandle]+_linalg_gemm2 args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),+               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gemm2"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_gemm2_upd ::+                  forall args . Fullfilled "_linalg_gemm2(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_linalg_gemm2(ndarray)" args -> IO ()+_linalg_gemm2_upd outputs args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),+               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gemm2"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_gemm2(ndarray)" = '[]++_backward_linalg_gemm2 ::+                       forall args . Fullfilled "_backward_linalg_gemm2(ndarray)" args =>+                         ArgsHMap "_backward_linalg_gemm2(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_linalg_gemm2 args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gemm2"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_gemm2_upd ::+                           forall args . Fullfilled "_backward_linalg_gemm2(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_linalg_gemm2(ndarray)" args -> IO ()+_backward_linalg_gemm2_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gemm2"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_potrf(ndarray)" =+     '[ '("_A", AttrOpt NDArrayHandle)]++_linalg_potrf ::+              forall args . Fullfilled "_linalg_potrf(ndarray)" args =>+                ArgsHMap "_linalg_potrf(ndarray)" args -> IO [NDArrayHandle]+_linalg_potrf args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_potrf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_potrf_upd ::+                  forall args . Fullfilled "_linalg_potrf(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_linalg_potrf(ndarray)" args -> IO ()+_linalg_potrf_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_potrf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_potrf(ndarray)" = '[]++_backward_linalg_potrf ::+                       forall args . Fullfilled "_backward_linalg_potrf(ndarray)" args =>+                         ArgsHMap "_backward_linalg_potrf(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_linalg_potrf args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_potrf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_potrf_upd ::+                           forall args . Fullfilled "_backward_linalg_potrf(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_linalg_potrf(ndarray)" args -> IO ()+_backward_linalg_potrf_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_potrf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_potri(ndarray)" =+     '[ '("_A", AttrOpt NDArrayHandle)]++_linalg_potri ::+              forall args . Fullfilled "_linalg_potri(ndarray)" args =>+                ArgsHMap "_linalg_potri(ndarray)" args -> IO [NDArrayHandle]+_linalg_potri args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_potri"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_potri_upd ::+                  forall args . Fullfilled "_linalg_potri(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_linalg_potri(ndarray)" args -> IO ()+_linalg_potri_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_potri"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_potri(ndarray)" = '[]++_backward_linalg_potri ::+                       forall args . Fullfilled "_backward_linalg_potri(ndarray)" args =>+                         ArgsHMap "_backward_linalg_potri(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_linalg_potri args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_potri"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_potri_upd ::+                           forall args . Fullfilled "_backward_linalg_potri(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_linalg_potri(ndarray)" args -> IO ()+_backward_linalg_potri_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_potri"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_trmm(ndarray)" =+     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),+        '("lower", AttrOpt Bool), '("alpha", AttrOpt Double),+        '("_A", AttrOpt NDArrayHandle), '("_B", AttrOpt NDArrayHandle)]++_linalg_trmm ::+             forall args . Fullfilled "_linalg_trmm(ndarray)" args =>+               ArgsHMap "_linalg_trmm(ndarray)" args -> IO [NDArrayHandle]+_linalg_trmm args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),+               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),+               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_trmm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_trmm_upd ::+                 forall args . Fullfilled "_linalg_trmm(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_linalg_trmm(ndarray)" args -> IO ()+_linalg_trmm_upd outputs args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),+               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),+               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_trmm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_trmm(ndarray)" = '[]++_backward_linalg_trmm ::+                      forall args . Fullfilled "_backward_linalg_trmm(ndarray)" args =>+                        ArgsHMap "_backward_linalg_trmm(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_linalg_trmm args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_trmm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_trmm_upd ::+                          forall args . Fullfilled "_backward_linalg_trmm(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_linalg_trmm(ndarray)" args -> IO ()+_backward_linalg_trmm_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_trmm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_trsm(ndarray)" =+     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),+        '("lower", AttrOpt Bool), '("alpha", AttrOpt Double),+        '("_A", AttrOpt NDArrayHandle), '("_B", AttrOpt NDArrayHandle)]++_linalg_trsm ::+             forall args . Fullfilled "_linalg_trsm(ndarray)" args =>+               ArgsHMap "_linalg_trsm(ndarray)" args -> IO [NDArrayHandle]+_linalg_trsm args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),+               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),+               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_trsm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_trsm_upd ::+                 forall args . Fullfilled "_linalg_trsm(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_linalg_trsm(ndarray)" args -> IO ()+_linalg_trsm_upd outputs args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),+               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),+               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_trsm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_trsm(ndarray)" = '[]++_backward_linalg_trsm ::+                      forall args . Fullfilled "_backward_linalg_trsm(ndarray)" args =>+                        ArgsHMap "_backward_linalg_trsm(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_linalg_trsm args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_trsm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_trsm_upd ::+                          forall args . Fullfilled "_backward_linalg_trsm(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_linalg_trsm(ndarray)" args -> IO ()+_backward_linalg_trsm_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_trsm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_sumlogdiag(ndarray)" =+     '[ '("_A", AttrOpt NDArrayHandle)]++_linalg_sumlogdiag ::+                   forall args . Fullfilled "_linalg_sumlogdiag(ndarray)" args =>+                     ArgsHMap "_linalg_sumlogdiag(ndarray)" args -> IO [NDArrayHandle]+_linalg_sumlogdiag args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_sumlogdiag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_sumlogdiag_upd ::+                       forall args . Fullfilled "_linalg_sumlogdiag(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_linalg_sumlogdiag(ndarray)" args -> IO ()+_linalg_sumlogdiag_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_sumlogdiag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_sumlogdiag(ndarray)"+     = '[]++_backward_linalg_sumlogdiag ::+                            forall args .+                              Fullfilled "_backward_linalg_sumlogdiag(ndarray)" args =>+                              ArgsHMap "_backward_linalg_sumlogdiag(ndarray)" args ->+                                IO [NDArrayHandle]+_backward_linalg_sumlogdiag args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_sumlogdiag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_sumlogdiag_upd ::+                                forall args .+                                  Fullfilled "_backward_linalg_sumlogdiag(ndarray)" args =>+                                  [NDArrayHandle] ->+                                    ArgsHMap "_backward_linalg_sumlogdiag(ndarray)" args -> IO ()+_backward_linalg_sumlogdiag_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_sumlogdiag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_syrk(ndarray)" =+     '[ '("transpose", AttrOpt Bool), '("alpha", AttrOpt Double),+        '("_A", AttrOpt NDArrayHandle)]++_linalg_syrk ::+             forall args . Fullfilled "_linalg_syrk(ndarray)" args =>+               ArgsHMap "_linalg_syrk(ndarray)" args -> IO [NDArrayHandle]+_linalg_syrk args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_syrk"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_syrk_upd ::+                 forall args . Fullfilled "_linalg_syrk(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_linalg_syrk(ndarray)" args -> IO ()+_linalg_syrk_upd outputs args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_syrk"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_syrk(ndarray)" = '[]++_backward_linalg_syrk ::+                      forall args . Fullfilled "_backward_linalg_syrk(ndarray)" args =>+                        ArgsHMap "_backward_linalg_syrk(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_linalg_syrk args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_syrk"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_syrk_upd ::+                          forall args . Fullfilled "_backward_linalg_syrk(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_linalg_syrk(ndarray)" args -> IO ()+_backward_linalg_syrk_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_syrk"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_gelqf(ndarray)" =+     '[ '("_A", AttrOpt NDArrayHandle)]++_linalg_gelqf ::+              forall args . Fullfilled "_linalg_gelqf(ndarray)" args =>+                ArgsHMap "_linalg_gelqf(ndarray)" args -> IO [NDArrayHandle]+_linalg_gelqf args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gelqf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_gelqf_upd ::+                  forall args . Fullfilled "_linalg_gelqf(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_linalg_gelqf(ndarray)" args -> IO ()+_linalg_gelqf_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gelqf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_gelqf(ndarray)" = '[]++_backward_linalg_gelqf ::+                       forall args . Fullfilled "_backward_linalg_gelqf(ndarray)" args =>+                         ArgsHMap "_backward_linalg_gelqf(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_linalg_gelqf args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gelqf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_gelqf_upd ::+                           forall args . Fullfilled "_backward_linalg_gelqf(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_linalg_gelqf(ndarray)" args -> IO ()+_backward_linalg_gelqf_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gelqf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_syevd(ndarray)" =+     '[ '("_A", AttrOpt NDArrayHandle)]++_linalg_syevd ::+              forall args . Fullfilled "_linalg_syevd(ndarray)" args =>+                ArgsHMap "_linalg_syevd(ndarray)" args -> IO [NDArrayHandle]+_linalg_syevd args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_syevd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_syevd_upd ::+                  forall args . Fullfilled "_linalg_syevd(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_linalg_syevd(ndarray)" args -> IO ()+_linalg_syevd_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_syevd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_syevd(ndarray)" = '[]++_backward_linalg_syevd ::+                       forall args . Fullfilled "_backward_linalg_syevd(ndarray)" args =>+                         ArgsHMap "_backward_linalg_syevd(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_linalg_syevd args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_syevd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_syevd_upd ::+                           forall args . Fullfilled "_backward_linalg_syevd(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_linalg_syevd(ndarray)" args -> IO ()+_backward_linalg_syevd_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_syevd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_histogram(ndarray)" =+     '[ '("bin_cnt", AttrOpt (Maybe Int)), '("range", AttrOpt Int),+        '("data", AttrOpt NDArrayHandle), '("bins", AttrOpt NDArrayHandle)]++_histogram ::+           forall args . Fullfilled "_histogram(ndarray)" args =>+             ArgsHMap "_histogram(ndarray)" args -> IO [NDArrayHandle]+_histogram args+  = let scalarArgs+          = catMaybes+              [("bin_cnt",) . showValue <$>+                 (args !? #bin_cnt :: Maybe (Maybe Int)),+               ("range",) . showValue <$> (args !? #range :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("bins",) <$> (args !? #bins :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_histogram"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_histogram_upd ::+               forall args . Fullfilled "_histogram(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "_histogram(ndarray)" args -> IO ()+_histogram_upd outputs args+  = let scalarArgs+          = catMaybes+              [("bin_cnt",) . showValue <$>+                 (args !? #bin_cnt :: Maybe (Maybe Int)),+               ("range",) . showValue <$> (args !? #range :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("bins",) <$> (args !? #bins :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_histogram"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "cast_storage(ndarray)" =+     '[ '("stype",+          AttrReq (EnumType '["csr", "default", "row_sparse"])),+        '("data", AttrOpt NDArrayHandle)]++cast_storage ::+             forall args . Fullfilled "cast_storage(ndarray)" args =>+               ArgsHMap "cast_storage(ndarray)" args -> IO [NDArrayHandle]+cast_storage args+  = let scalarArgs+          = catMaybes+              [("stype",) . showValue <$>+                 (args !? #stype ::+                    Maybe (EnumType '["csr", "default", "row_sparse"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cast_storage"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++cast_storage_upd ::+                 forall args . Fullfilled "cast_storage(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "cast_storage(ndarray)" args -> IO ()+cast_storage_upd outputs args+  = let scalarArgs+          = catMaybes+              [("stype",) . showValue <$>+                 (args !? #stype ::+                    Maybe (EnumType '["csr", "default", "row_sparse"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cast_storage"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_equal_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_equal_scalar ::+              forall args . Fullfilled "_equal_scalar(ndarray)" args =>+                ArgsHMap "_equal_scalar(ndarray)" args -> IO [NDArrayHandle]+_equal_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_equal_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_equal_scalar_upd ::+                  forall args . Fullfilled "_equal_scalar(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_equal_scalar(ndarray)" args -> IO ()+_equal_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_equal_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_not_equal_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_not_equal_scalar ::+                  forall args . Fullfilled "_not_equal_scalar(ndarray)" args =>+                    ArgsHMap "_not_equal_scalar(ndarray)" args -> IO [NDArrayHandle]+_not_equal_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_not_equal_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_not_equal_scalar_upd ::+                      forall args . Fullfilled "_not_equal_scalar(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_not_equal_scalar(ndarray)" args -> IO ()+_not_equal_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_not_equal_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_greater_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_greater_scalar ::+                forall args . Fullfilled "_greater_scalar(ndarray)" args =>+                  ArgsHMap "_greater_scalar(ndarray)" args -> IO [NDArrayHandle]+_greater_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_greater_scalar_upd ::+                    forall args . Fullfilled "_greater_scalar(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_greater_scalar(ndarray)" args -> IO ()+_greater_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_greater_equal_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_greater_equal_scalar ::+                      forall args . Fullfilled "_greater_equal_scalar(ndarray)" args =>+                        ArgsHMap "_greater_equal_scalar(ndarray)" args ->+                          IO [NDArrayHandle]+_greater_equal_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_equal_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_greater_equal_scalar_upd ::+                          forall args . Fullfilled "_greater_equal_scalar(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_greater_equal_scalar(ndarray)" args -> IO ()+_greater_equal_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_equal_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_lesser_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_lesser_scalar ::+               forall args . Fullfilled "_lesser_scalar(ndarray)" args =>+                 ArgsHMap "_lesser_scalar(ndarray)" args -> IO [NDArrayHandle]+_lesser_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_lesser_scalar_upd ::+                   forall args . Fullfilled "_lesser_scalar(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_lesser_scalar(ndarray)" args -> IO ()+_lesser_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_lesser_equal_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_lesser_equal_scalar ::+                     forall args . Fullfilled "_lesser_equal_scalar(ndarray)" args =>+                       ArgsHMap "_lesser_equal_scalar(ndarray)" args -> IO [NDArrayHandle]+_lesser_equal_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_equal_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_lesser_equal_scalar_upd ::+                         forall args . Fullfilled "_lesser_equal_scalar(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_lesser_equal_scalar(ndarray)" args -> IO ()+_lesser_equal_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_equal_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_logical_and_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_logical_and_scalar ::+                    forall args . Fullfilled "_logical_and_scalar(ndarray)" args =>+                      ArgsHMap "_logical_and_scalar(ndarray)" args -> IO [NDArrayHandle]+_logical_and_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_and_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_logical_and_scalar_upd ::+                        forall args . Fullfilled "_logical_and_scalar(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_logical_and_scalar(ndarray)" args -> IO ()+_logical_and_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_and_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_logical_or_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_logical_or_scalar ::+                   forall args . Fullfilled "_logical_or_scalar(ndarray)" args =>+                     ArgsHMap "_logical_or_scalar(ndarray)" args -> IO [NDArrayHandle]+_logical_or_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_or_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_logical_or_scalar_upd ::+                       forall args . Fullfilled "_logical_or_scalar(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_logical_or_scalar(ndarray)" args -> IO ()+_logical_or_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_or_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_logical_xor_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_logical_xor_scalar ::+                    forall args . Fullfilled "_logical_xor_scalar(ndarray)" args =>+                      ArgsHMap "_logical_xor_scalar(ndarray)" args -> IO [NDArrayHandle]+_logical_xor_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_xor_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_logical_xor_scalar_upd ::+                        forall args . Fullfilled "_logical_xor_scalar(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_logical_xor_scalar(ndarray)" args -> IO ()+_logical_xor_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_xor_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "relu(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++relu ::+     forall args . Fullfilled "relu(ndarray)" args =>+       ArgsHMap "relu(ndarray)" args -> IO [NDArrayHandle]+relu args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "relu"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++relu_upd ::+         forall args . Fullfilled "relu(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "relu(ndarray)" args -> IO ()+relu_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "relu"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_relu(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_relu ::+               forall args . Fullfilled "_backward_relu(ndarray)" args =>+                 ArgsHMap "_backward_relu(ndarray)" args -> IO [NDArrayHandle]+_backward_relu args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_relu"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_relu_upd ::+                   forall args . Fullfilled "_backward_relu(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_relu(ndarray)" args -> IO ()+_backward_relu_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_relu"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "sigmoid(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++sigmoid ::+        forall args . Fullfilled "sigmoid(ndarray)" args =>+          ArgsHMap "sigmoid(ndarray)" args -> IO [NDArrayHandle]+sigmoid args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sigmoid"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++sigmoid_upd ::+            forall args . Fullfilled "sigmoid(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "sigmoid(ndarray)" args -> IO ()+sigmoid_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sigmoid"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_sigmoid(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_sigmoid ::+                  forall args . Fullfilled "_backward_sigmoid(ndarray)" args =>+                    ArgsHMap "_backward_sigmoid(ndarray)" args -> IO [NDArrayHandle]+_backward_sigmoid args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sigmoid"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_sigmoid_upd ::+                      forall args . Fullfilled "_backward_sigmoid(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_sigmoid(ndarray)" args -> IO ()+_backward_sigmoid_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sigmoid"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "hard_sigmoid(ndarray)" =+     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle)]++hard_sigmoid ::+             forall args . Fullfilled "hard_sigmoid(ndarray)" args =>+               ArgsHMap "hard_sigmoid(ndarray)" args -> IO [NDArrayHandle]+hard_sigmoid args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "hard_sigmoid"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++hard_sigmoid_upd ::+                 forall args . Fullfilled "hard_sigmoid(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "hard_sigmoid(ndarray)" args -> IO ()+hard_sigmoid_upd outputs args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "hard_sigmoid"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_hard_sigmoid(ndarray)" = '[]++_backward_hard_sigmoid ::+                       forall args . Fullfilled "_backward_hard_sigmoid(ndarray)" args =>+                         ArgsHMap "_backward_hard_sigmoid(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_hard_sigmoid args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_hard_sigmoid"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_hard_sigmoid_upd ::+                           forall args . Fullfilled "_backward_hard_sigmoid(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_hard_sigmoid(ndarray)" args -> IO ()+_backward_hard_sigmoid_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_hard_sigmoid"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "softsign(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++softsign ::+         forall args . Fullfilled "softsign(ndarray)" args =>+           ArgsHMap "softsign(ndarray)" args -> IO [NDArrayHandle]+softsign args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softsign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++softsign_upd ::+             forall args . Fullfilled "softsign(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "softsign(ndarray)" args -> IO ()+softsign_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softsign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_softsign(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_softsign ::+                   forall args . Fullfilled "_backward_softsign(ndarray)" args =>+                     ArgsHMap "_backward_softsign(ndarray)" args -> IO [NDArrayHandle]+_backward_softsign args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_softsign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_softsign_upd ::+                       forall args . Fullfilled "_backward_softsign(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_backward_softsign(ndarray)" args -> IO ()+_backward_softsign_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_softsign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_copy(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_copy ::+      forall args . Fullfilled "_copy(ndarray)" args =>+        ArgsHMap "_copy(ndarray)" args -> IO [NDArrayHandle]+_copy args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_copy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_copy_upd ::+          forall args . Fullfilled "_copy(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "_copy(ndarray)" args -> IO ()+_copy_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_copy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_copy(ndarray)" = '[]++_backward_copy ::+               forall args . Fullfilled "_backward_copy(ndarray)" args =>+                 ArgsHMap "_backward_copy(ndarray)" args -> IO [NDArrayHandle]+_backward_copy args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_copy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_copy_upd ::+                   forall args . Fullfilled "_backward_copy(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_copy(ndarray)" args -> IO ()+_backward_copy_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_copy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_BlockGrad(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_BlockGrad ::+           forall args . Fullfilled "_BlockGrad(ndarray)" args =>+             ArgsHMap "_BlockGrad(ndarray)" args -> IO [NDArrayHandle]+_BlockGrad args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BlockGrad"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_BlockGrad_upd ::+               forall args . Fullfilled "_BlockGrad(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "_BlockGrad(ndarray)" args -> IO ()+_BlockGrad_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BlockGrad"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "make_loss(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++make_loss ::+          forall args . Fullfilled "make_loss(ndarray)" args =>+            ArgsHMap "make_loss(ndarray)" args -> IO [NDArrayHandle]+make_loss args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "make_loss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++make_loss_upd ::+              forall args . Fullfilled "make_loss(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "make_loss(ndarray)" args -> IO ()+make_loss_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "make_loss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_identity_with_attr_like_rhs(ndarray)"+     =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_identity_with_attr_like_rhs ::+                             forall args .+                               Fullfilled "_identity_with_attr_like_rhs(ndarray)" args =>+                               ArgsHMap "_identity_with_attr_like_rhs(ndarray)" args ->+                                 IO [NDArrayHandle]+_identity_with_attr_like_rhs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_identity_with_attr_like_rhs"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_identity_with_attr_like_rhs_upd ::+                                 forall args .+                                   Fullfilled "_identity_with_attr_like_rhs(ndarray)" args =>+                                   [NDArrayHandle] ->+                                     ArgsHMap "_identity_with_attr_like_rhs(ndarray)" args -> IO ()+_identity_with_attr_like_rhs_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_identity_with_attr_like_rhs"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "reshape_like(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++reshape_like ::+             forall args . Fullfilled "reshape_like(ndarray)" args =>+               ArgsHMap "reshape_like(ndarray)" args -> IO [NDArrayHandle]+reshape_like args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reshape_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++reshape_like_upd ::+                 forall args . Fullfilled "reshape_like(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "reshape_like(ndarray)" args -> IO ()+reshape_like_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reshape_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "shape_array(ndarray)" =+     '[ '("lhs_begin", AttrOpt (Maybe Int)),+        '("lhs_end", AttrOpt (Maybe Int)),+        '("rhs_begin", AttrOpt (Maybe Int)),+        '("rhs_end", AttrOpt (Maybe Int)),+        '("data", AttrOpt NDArrayHandle)]++shape_array ::+            forall args . Fullfilled "shape_array(ndarray)" args =>+              ArgsHMap "shape_array(ndarray)" args -> IO [NDArrayHandle]+shape_array args+  = let scalarArgs+          = catMaybes+              [("lhs_begin",) . showValue <$>+                 (args !? #lhs_begin :: Maybe (Maybe Int)),+               ("lhs_end",) . showValue <$>+                 (args !? #lhs_end :: Maybe (Maybe Int)),+               ("rhs_begin",) . showValue <$>+                 (args !? #rhs_begin :: Maybe (Maybe Int)),+               ("rhs_end",) . showValue <$>+                 (args !? #rhs_end :: Maybe (Maybe Int))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "shape_array"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++shape_array_upd ::+                forall args . Fullfilled "shape_array(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "shape_array(ndarray)" args -> IO ()+shape_array_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lhs_begin",) . showValue <$>+                 (args !? #lhs_begin :: Maybe (Maybe Int)),+               ("lhs_end",) . showValue <$>+                 (args !? #lhs_end :: Maybe (Maybe Int)),+               ("rhs_begin",) . showValue <$>+                 (args !? #rhs_begin :: Maybe (Maybe Int)),+               ("rhs_end",) . showValue <$>+                 (args !? #rhs_end :: Maybe (Maybe Int))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "shape_array"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "size_array(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++size_array ::+           forall args . Fullfilled "size_array(ndarray)" args =>+             ArgsHMap "size_array(ndarray)" args -> IO [NDArrayHandle]+size_array args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "size_array"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++size_array_upd ::+               forall args . Fullfilled "size_array(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "size_array(ndarray)" args -> IO ()+size_array_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "size_array"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Cast(ndarray)" =+     '[ '("dtype",+          AttrReq+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("data", AttrOpt NDArrayHandle)]++_Cast ::+      forall args . Fullfilled "_Cast(ndarray)" args =>+        ArgsHMap "_Cast(ndarray)" args -> IO [NDArrayHandle]+_Cast args+  = let scalarArgs+          = catMaybes+              [("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Cast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Cast_upd ::+          forall args . Fullfilled "_Cast(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "_Cast(ndarray)" args -> IO ()+_Cast_upd outputs args+  = let scalarArgs+          = catMaybes+              [("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Cast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_cast(ndarray)" = '[]++_backward_cast ::+               forall args . Fullfilled "_backward_cast(ndarray)" args =>+                 ArgsHMap "_backward_cast(ndarray)" args -> IO [NDArrayHandle]+_backward_cast args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_cast_upd ::+                   forall args . Fullfilled "_backward_cast(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_cast(ndarray)" args -> IO ()+_backward_cast_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "negative(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++negative ::+         forall args . Fullfilled "negative(ndarray)" args =>+           ArgsHMap "negative(ndarray)" args -> IO [NDArrayHandle]+negative args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "negative"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++negative_upd ::+             forall args . Fullfilled "negative(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "negative(ndarray)" args -> IO ()+negative_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "negative"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "reciprocal(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++reciprocal ::+           forall args . Fullfilled "reciprocal(ndarray)" args =>+             ArgsHMap "reciprocal(ndarray)" args -> IO [NDArrayHandle]+reciprocal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reciprocal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++reciprocal_upd ::+               forall args . Fullfilled "reciprocal(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "reciprocal(ndarray)" args -> IO ()+reciprocal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reciprocal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_reciprocal(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_reciprocal ::+                     forall args . Fullfilled "_backward_reciprocal(ndarray)" args =>+                       ArgsHMap "_backward_reciprocal(ndarray)" args -> IO [NDArrayHandle]+_backward_reciprocal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_reciprocal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_reciprocal_upd ::+                         forall args . Fullfilled "_backward_reciprocal(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_reciprocal(ndarray)" args -> IO ()+_backward_reciprocal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_reciprocal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "abs(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++abs ::+    forall args . Fullfilled "abs(ndarray)" args =>+      ArgsHMap "abs(ndarray)" args -> IO [NDArrayHandle]+abs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "abs"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++abs_upd ::+        forall args . Fullfilled "abs(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "abs(ndarray)" args -> IO ()+abs_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "abs"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_abs(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_abs ::+              forall args . Fullfilled "_backward_abs(ndarray)" args =>+                ArgsHMap "_backward_abs(ndarray)" args -> IO [NDArrayHandle]+_backward_abs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_abs"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_abs_upd ::+                  forall args . Fullfilled "_backward_abs(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_abs(ndarray)" args -> IO ()+_backward_abs_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_abs"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "sign(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++sign ::+     forall args . Fullfilled "sign(ndarray)" args =>+       ArgsHMap "sign(ndarray)" args -> IO [NDArrayHandle]+sign args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++sign_upd ::+         forall args . Fullfilled "sign(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "sign(ndarray)" args -> IO ()+sign_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_sign(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_sign ::+               forall args . Fullfilled "_backward_sign(ndarray)" args =>+                 ArgsHMap "_backward_sign(ndarray)" args -> IO [NDArrayHandle]+_backward_sign args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_sign_upd ::+                   forall args . Fullfilled "_backward_sign(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_sign(ndarray)" args -> IO ()+_backward_sign_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "round(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++round ::+      forall args . Fullfilled "round(ndarray)" args =>+        ArgsHMap "round(ndarray)" args -> IO [NDArrayHandle]+round args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "round"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++round_upd ::+          forall args . Fullfilled "round(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "round(ndarray)" args -> IO ()+round_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "round"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "rint(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++rint ::+     forall args . Fullfilled "rint(ndarray)" args =>+       ArgsHMap "rint(ndarray)" args -> IO [NDArrayHandle]+rint args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rint"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++rint_upd ::+         forall args . Fullfilled "rint(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "rint(ndarray)" args -> IO ()+rint_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rint"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "ceil(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++ceil ::+     forall args . Fullfilled "ceil(ndarray)" args =>+       ArgsHMap "ceil(ndarray)" args -> IO [NDArrayHandle]+ceil args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ceil"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++ceil_upd ::+         forall args . Fullfilled "ceil(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "ceil(ndarray)" args -> IO ()+ceil_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ceil"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "floor(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++floor ::+      forall args . Fullfilled "floor(ndarray)" args =>+        ArgsHMap "floor(ndarray)" args -> IO [NDArrayHandle]+floor args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "floor"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++floor_upd ::+          forall args . Fullfilled "floor(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "floor(ndarray)" args -> IO ()+floor_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "floor"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "trunc(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++trunc ::+      forall args . Fullfilled "trunc(ndarray)" args =>+        ArgsHMap "trunc(ndarray)" args -> IO [NDArrayHandle]+trunc args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "trunc"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++trunc_upd ::+          forall args . Fullfilled "trunc(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "trunc(ndarray)" args -> IO ()+trunc_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "trunc"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "fix(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++fix ::+    forall args . Fullfilled "fix(ndarray)" args =>+      ArgsHMap "fix(ndarray)" args -> IO [NDArrayHandle]+fix args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "fix"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++fix_upd ::+        forall args . Fullfilled "fix(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "fix(ndarray)" args -> IO ()+fix_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "fix"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "square(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++square ::+       forall args . Fullfilled "square(ndarray)" args =>+         ArgsHMap "square(ndarray)" args -> IO [NDArrayHandle]+square args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "square"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++square_upd ::+           forall args . Fullfilled "square(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "square(ndarray)" args -> IO ()+square_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "square"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_square(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_square ::+                 forall args . Fullfilled "_backward_square(ndarray)" args =>+                   ArgsHMap "_backward_square(ndarray)" args -> IO [NDArrayHandle]+_backward_square args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_square"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_square_upd ::+                     forall args . Fullfilled "_backward_square(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_backward_square(ndarray)" args -> IO ()+_backward_square_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_square"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "sqrt(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++sqrt ::+     forall args . Fullfilled "sqrt(ndarray)" args =>+       ArgsHMap "sqrt(ndarray)" args -> IO [NDArrayHandle]+sqrt args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sqrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++sqrt_upd ::+         forall args . Fullfilled "sqrt(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "sqrt(ndarray)" args -> IO ()+sqrt_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sqrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_sqrt(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_sqrt ::+               forall args . Fullfilled "_backward_sqrt(ndarray)" args =>+                 ArgsHMap "_backward_sqrt(ndarray)" args -> IO [NDArrayHandle]+_backward_sqrt args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sqrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_sqrt_upd ::+                   forall args . Fullfilled "_backward_sqrt(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_sqrt(ndarray)" args -> IO ()+_backward_sqrt_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sqrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "rsqrt(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++rsqrt ::+      forall args . Fullfilled "rsqrt(ndarray)" args =>+        ArgsHMap "rsqrt(ndarray)" args -> IO [NDArrayHandle]+rsqrt args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rsqrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++rsqrt_upd ::+          forall args . Fullfilled "rsqrt(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "rsqrt(ndarray)" args -> IO ()+rsqrt_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rsqrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_rsqrt(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_rsqrt ::+                forall args . Fullfilled "_backward_rsqrt(ndarray)" args =>+                  ArgsHMap "_backward_rsqrt(ndarray)" args -> IO [NDArrayHandle]+_backward_rsqrt args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rsqrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_rsqrt_upd ::+                    forall args . Fullfilled "_backward_rsqrt(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_rsqrt(ndarray)" args -> IO ()+_backward_rsqrt_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rsqrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "cbrt(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++cbrt ::+     forall args . Fullfilled "cbrt(ndarray)" args =>+       ArgsHMap "cbrt(ndarray)" args -> IO [NDArrayHandle]+cbrt args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cbrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++cbrt_upd ::+         forall args . Fullfilled "cbrt(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "cbrt(ndarray)" args -> IO ()+cbrt_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cbrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_cbrt(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_cbrt ::+               forall args . Fullfilled "_backward_cbrt(ndarray)" args =>+                 ArgsHMap "_backward_cbrt(ndarray)" args -> IO [NDArrayHandle]+_backward_cbrt args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cbrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_cbrt_upd ::+                   forall args . Fullfilled "_backward_cbrt(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_cbrt(ndarray)" args -> IO ()+_backward_cbrt_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cbrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "erf(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++erf ::+    forall args . Fullfilled "erf(ndarray)" args =>+      ArgsHMap "erf(ndarray)" args -> IO [NDArrayHandle]+erf args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "erf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++erf_upd ::+        forall args . Fullfilled "erf(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "erf(ndarray)" args -> IO ()+erf_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "erf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_erf(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_erf ::+              forall args . Fullfilled "_backward_erf(ndarray)" args =>+                ArgsHMap "_backward_erf(ndarray)" args -> IO [NDArrayHandle]+_backward_erf args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_erf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_erf_upd ::+                  forall args . Fullfilled "_backward_erf(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_erf(ndarray)" args -> IO ()+_backward_erf_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_erf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "rcbrt(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++rcbrt ::+      forall args . Fullfilled "rcbrt(ndarray)" args =>+        ArgsHMap "rcbrt(ndarray)" args -> IO [NDArrayHandle]+rcbrt args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rcbrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++rcbrt_upd ::+          forall args . Fullfilled "rcbrt(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "rcbrt(ndarray)" args -> IO ()+rcbrt_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rcbrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_rcbrt(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_rcbrt ::+                forall args . Fullfilled "_backward_rcbrt(ndarray)" args =>+                  ArgsHMap "_backward_rcbrt(ndarray)" args -> IO [NDArrayHandle]+_backward_rcbrt args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rcbrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_rcbrt_upd ::+                    forall args . Fullfilled "_backward_rcbrt(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_rcbrt(ndarray)" args -> IO ()+_backward_rcbrt_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rcbrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "exp(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++exp ::+    forall args . Fullfilled "exp(ndarray)" args =>+      ArgsHMap "exp(ndarray)" args -> IO [NDArrayHandle]+exp args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "exp"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++exp_upd ::+        forall args . Fullfilled "exp(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "exp(ndarray)" args -> IO ()+exp_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "exp"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "log(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++log ::+    forall args . Fullfilled "log(ndarray)" args =>+      ArgsHMap "log(ndarray)" args -> IO [NDArrayHandle]+log args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++log_upd ::+        forall args . Fullfilled "log(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "log(ndarray)" args -> IO ()+log_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "log10(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++log10 ::+      forall args . Fullfilled "log10(ndarray)" args =>+        ArgsHMap "log10(ndarray)" args -> IO [NDArrayHandle]+log10 args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log10"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++log10_upd ::+          forall args . Fullfilled "log10(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "log10(ndarray)" args -> IO ()+log10_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log10"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "log2(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++log2 ::+     forall args . Fullfilled "log2(ndarray)" args =>+       ArgsHMap "log2(ndarray)" args -> IO [NDArrayHandle]+log2 args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log2"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++log2_upd ::+         forall args . Fullfilled "log2(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "log2(ndarray)" args -> IO ()+log2_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log2"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_log(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_log ::+              forall args . Fullfilled "_backward_log(ndarray)" args =>+                ArgsHMap "_backward_log(ndarray)" args -> IO [NDArrayHandle]+_backward_log args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_log_upd ::+                  forall args . Fullfilled "_backward_log(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_log(ndarray)" args -> IO ()+_backward_log_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_log10(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_log10 ::+                forall args . Fullfilled "_backward_log10(ndarray)" args =>+                  ArgsHMap "_backward_log10(ndarray)" args -> IO [NDArrayHandle]+_backward_log10 args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log10"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_log10_upd ::+                    forall args . Fullfilled "_backward_log10(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_log10(ndarray)" args -> IO ()+_backward_log10_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log10"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_log2(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_log2 ::+               forall args . Fullfilled "_backward_log2(ndarray)" args =>+                 ArgsHMap "_backward_log2(ndarray)" args -> IO [NDArrayHandle]+_backward_log2 args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log2"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_log2_upd ::+                   forall args . Fullfilled "_backward_log2(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_log2(ndarray)" args -> IO ()+_backward_log2_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log2"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "log1p(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++log1p ::+      forall args . Fullfilled "log1p(ndarray)" args =>+        ArgsHMap "log1p(ndarray)" args -> IO [NDArrayHandle]+log1p args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log1p"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++log1p_upd ::+          forall args . Fullfilled "log1p(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "log1p(ndarray)" args -> IO ()+log1p_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log1p"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_log1p(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_log1p ::+                forall args . Fullfilled "_backward_log1p(ndarray)" args =>+                  ArgsHMap "_backward_log1p(ndarray)" args -> IO [NDArrayHandle]+_backward_log1p args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log1p"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_log1p_upd ::+                    forall args . Fullfilled "_backward_log1p(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_log1p(ndarray)" args -> IO ()+_backward_log1p_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log1p"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "expm1(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++expm1 ::+      forall args . Fullfilled "expm1(ndarray)" args =>+        ArgsHMap "expm1(ndarray)" args -> IO [NDArrayHandle]+expm1 args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "expm1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++expm1_upd ::+          forall args . Fullfilled "expm1(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "expm1(ndarray)" args -> IO ()+expm1_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "expm1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_expm1(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_expm1 ::+                forall args . Fullfilled "_backward_expm1(ndarray)" args =>+                  ArgsHMap "_backward_expm1(ndarray)" args -> IO [NDArrayHandle]+_backward_expm1 args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_expm1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_expm1_upd ::+                    forall args . Fullfilled "_backward_expm1(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_expm1(ndarray)" args -> IO ()+_backward_expm1_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_expm1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "gamma(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++gamma ::+      forall args . Fullfilled "gamma(ndarray)" args =>+        ArgsHMap "gamma(ndarray)" args -> IO [NDArrayHandle]+gamma args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gamma"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++gamma_upd ::+          forall args . Fullfilled "gamma(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "gamma(ndarray)" args -> IO ()+gamma_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gamma"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_gamma(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_gamma ::+                forall args . Fullfilled "_backward_gamma(ndarray)" args =>+                  ArgsHMap "_backward_gamma(ndarray)" args -> IO [NDArrayHandle]+_backward_gamma args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_gamma"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_gamma_upd ::+                    forall args . Fullfilled "_backward_gamma(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_gamma(ndarray)" args -> IO ()+_backward_gamma_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_gamma"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "gammaln(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++gammaln ::+        forall args . Fullfilled "gammaln(ndarray)" args =>+          ArgsHMap "gammaln(ndarray)" args -> IO [NDArrayHandle]+gammaln args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gammaln"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++gammaln_upd ::+            forall args . Fullfilled "gammaln(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "gammaln(ndarray)" args -> IO ()+gammaln_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gammaln"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_gammaln(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_gammaln ::+                  forall args . Fullfilled "_backward_gammaln(ndarray)" args =>+                    ArgsHMap "_backward_gammaln(ndarray)" args -> IO [NDArrayHandle]+_backward_gammaln args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_gammaln"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_gammaln_upd ::+                      forall args . Fullfilled "_backward_gammaln(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_gammaln(ndarray)" args -> IO ()+_backward_gammaln_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_gammaln"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "logical_not(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++logical_not ::+            forall args . Fullfilled "logical_not(ndarray)" args =>+              ArgsHMap "logical_not(ndarray)" args -> IO [NDArrayHandle]+logical_not args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "logical_not"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++logical_not_upd ::+                forall args . Fullfilled "logical_not(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "logical_not(ndarray)" args -> IO ()+logical_not_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "logical_not"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "sum(ndarray)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++sum ::+    forall args . Fullfilled "sum(ndarray)" args =>+      ArgsHMap "sum(ndarray)" args -> IO [NDArrayHandle]+sum args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++sum_upd ::+        forall args . Fullfilled "sum(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "sum(ndarray)" args -> IO ()+sum_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_sum(ndarray)" = '[]++_backward_sum ::+              forall args . Fullfilled "_backward_sum(ndarray)" args =>+                ArgsHMap "_backward_sum(ndarray)" args -> IO [NDArrayHandle]+_backward_sum args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_sum_upd ::+                  forall args . Fullfilled "_backward_sum(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_sum(ndarray)" args -> IO ()+_backward_sum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "mean(ndarray)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++mean ::+     forall args . Fullfilled "mean(ndarray)" args =>+       ArgsHMap "mean(ndarray)" args -> IO [NDArrayHandle]+mean args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mean"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++mean_upd ::+         forall args . Fullfilled "mean(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "mean(ndarray)" args -> IO ()+mean_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mean"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_mean(ndarray)" = '[]++_backward_mean ::+               forall args . Fullfilled "_backward_mean(ndarray)" args =>+                 ArgsHMap "_backward_mean(ndarray)" args -> IO [NDArrayHandle]+_backward_mean args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mean"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_mean_upd ::+                   forall args . Fullfilled "_backward_mean(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_mean(ndarray)" args -> IO ()+_backward_mean_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mean"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "prod(ndarray)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++prod ::+     forall args . Fullfilled "prod(ndarray)" args =>+       ArgsHMap "prod(ndarray)" args -> IO [NDArrayHandle]+prod args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "prod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++prod_upd ::+         forall args . Fullfilled "prod(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "prod(ndarray)" args -> IO ()+prod_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "prod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_prod(ndarray)" = '[]++_backward_prod ::+               forall args . Fullfilled "_backward_prod(ndarray)" args =>+                 ArgsHMap "_backward_prod(ndarray)" args -> IO [NDArrayHandle]+_backward_prod args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_prod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_prod_upd ::+                   forall args . Fullfilled "_backward_prod(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_prod(ndarray)" args -> IO ()+_backward_prod_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_prod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "nansum(ndarray)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++nansum ::+       forall args . Fullfilled "nansum(ndarray)" args =>+         ArgsHMap "nansum(ndarray)" args -> IO [NDArrayHandle]+nansum args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "nansum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++nansum_upd ::+           forall args . Fullfilled "nansum(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "nansum(ndarray)" args -> IO ()+nansum_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "nansum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_nansum(ndarray)" = '[]++_backward_nansum ::+                 forall args . Fullfilled "_backward_nansum(ndarray)" args =>+                   ArgsHMap "_backward_nansum(ndarray)" args -> IO [NDArrayHandle]+_backward_nansum args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_nansum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_nansum_upd ::+                     forall args . Fullfilled "_backward_nansum(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_backward_nansum(ndarray)" args -> IO ()+_backward_nansum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_nansum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "nanprod(ndarray)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++nanprod ::+        forall args . Fullfilled "nanprod(ndarray)" args =>+          ArgsHMap "nanprod(ndarray)" args -> IO [NDArrayHandle]+nanprod args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "nanprod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++nanprod_upd ::+            forall args . Fullfilled "nanprod(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "nanprod(ndarray)" args -> IO ()+nanprod_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "nanprod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_nanprod(ndarray)" = '[]++_backward_nanprod ::+                  forall args . Fullfilled "_backward_nanprod(ndarray)" args =>+                    ArgsHMap "_backward_nanprod(ndarray)" args -> IO [NDArrayHandle]+_backward_nanprod args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_nanprod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_nanprod_upd ::+                      forall args . Fullfilled "_backward_nanprod(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_nanprod(ndarray)" args -> IO ()+_backward_nanprod_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_nanprod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "max(ndarray)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++max ::+    forall args . Fullfilled "max(ndarray)" args =>+      ArgsHMap "max(ndarray)" args -> IO [NDArrayHandle]+max args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "max"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++max_upd ::+        forall args . Fullfilled "max(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "max(ndarray)" args -> IO ()+max_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "max"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_max(ndarray)" = '[]++_backward_max ::+              forall args . Fullfilled "_backward_max(ndarray)" args =>+                ArgsHMap "_backward_max(ndarray)" args -> IO [NDArrayHandle]+_backward_max args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_max"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_max_upd ::+                  forall args . Fullfilled "_backward_max(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_max(ndarray)" args -> IO ()+_backward_max_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_max"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "min(ndarray)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++min ::+    forall args . Fullfilled "min(ndarray)" args =>+      ArgsHMap "min(ndarray)" args -> IO [NDArrayHandle]+min args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "min"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++min_upd ::+        forall args . Fullfilled "min(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "min(ndarray)" args -> IO ()+min_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "min"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_min(ndarray)" = '[]++_backward_min ::+              forall args . Fullfilled "_backward_min(ndarray)" args =>+                ArgsHMap "_backward_min(ndarray)" args -> IO [NDArrayHandle]+_backward_min args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_min"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_min_upd ::+                  forall args . Fullfilled "_backward_min(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_min(ndarray)" args -> IO ()+_backward_min_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_min"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_axis(ndarray)" =+     '[ '("axis", AttrOpt [Int]), '("size", AttrOpt [Int]),+        '("data", AttrOpt NDArrayHandle)]++broadcast_axis ::+               forall args . Fullfilled "broadcast_axis(ndarray)" args =>+                 ArgsHMap "broadcast_axis(ndarray)" args -> IO [NDArrayHandle]+broadcast_axis args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),+               ("size",) . showValue <$> (args !? #size :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_axis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_axis_upd ::+                   forall args . Fullfilled "broadcast_axis(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "broadcast_axis(ndarray)" args -> IO ()+broadcast_axis_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),+               ("size",) . showValue <$> (args !? #size :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_axis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_to(ndarray)" =+     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]++broadcast_to ::+             forall args . Fullfilled "broadcast_to(ndarray)" args =>+               ArgsHMap "broadcast_to(ndarray)" args -> IO [NDArrayHandle]+broadcast_to args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_to"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_to_upd ::+                 forall args . Fullfilled "broadcast_to(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "broadcast_to(ndarray)" args -> IO ()+broadcast_to_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_to"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_broadcast_backward(ndarray)" = '[]++_broadcast_backward ::+                    forall args . Fullfilled "_broadcast_backward(ndarray)" args =>+                      ArgsHMap "_broadcast_backward(ndarray)" args -> IO [NDArrayHandle]+_broadcast_backward args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_broadcast_backward"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_broadcast_backward_upd ::+                        forall args . Fullfilled "_broadcast_backward(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_broadcast_backward(ndarray)" args -> IO ()+_broadcast_backward_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_broadcast_backward"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_like(ndarray)" =+     '[ '("lhs_axes", AttrOpt (Maybe [Int])),+        '("rhs_axes", AttrOpt (Maybe [Int])),+        '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]++broadcast_like ::+               forall args . Fullfilled "broadcast_like(ndarray)" args =>+                 ArgsHMap "broadcast_like(ndarray)" args -> IO [NDArrayHandle]+broadcast_like args+  = let scalarArgs+          = catMaybes+              [("lhs_axes",) . showValue <$>+                 (args !? #lhs_axes :: Maybe (Maybe [Int])),+               ("rhs_axes",) . showValue <$>+                 (args !? #rhs_axes :: Maybe (Maybe [Int]))]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_like_upd ::+                   forall args . Fullfilled "broadcast_like(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "broadcast_like(ndarray)" args -> IO ()+broadcast_like_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lhs_axes",) . showValue <$>+                 (args !? #lhs_axes :: Maybe (Maybe [Int])),+               ("rhs_axes",) . showValue <$>+                 (args !? #rhs_axes :: Maybe (Maybe [Int]))]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "norm(ndarray)" =+     '[ '("ord", AttrOpt Int), '("axis", AttrOpt (Maybe [Int])),+        '("keepdims", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++norm ::+     forall args . Fullfilled "norm(ndarray)" args =>+       ArgsHMap "norm(ndarray)" args -> IO [NDArrayHandle]+norm args+  = let scalarArgs+          = catMaybes+              [("ord",) . showValue <$> (args !? #ord :: Maybe Int),+               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "norm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++norm_upd ::+         forall args . Fullfilled "norm(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "norm(ndarray)" args -> IO ()+norm_upd outputs args+  = let scalarArgs+          = catMaybes+              [("ord",) . showValue <$> (args !? #ord :: Maybe Int),+               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "norm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_norm(ndarray)" = '[]++_backward_norm ::+               forall args . Fullfilled "_backward_norm(ndarray)" args =>+                 ArgsHMap "_backward_norm(ndarray)" args -> IO [NDArrayHandle]+_backward_norm args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_norm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_norm_upd ::+                   forall args . Fullfilled "_backward_norm(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_norm(ndarray)" args -> IO ()+_backward_norm_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_norm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "elemwise_add(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++elemwise_add ::+             forall args . Fullfilled "elemwise_add(ndarray)" args =>+               ArgsHMap "elemwise_add(ndarray)" args -> IO [NDArrayHandle]+elemwise_add args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++elemwise_add_upd ::+                 forall args . Fullfilled "elemwise_add(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "elemwise_add(ndarray)" args -> IO ()+elemwise_add_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_grad_add(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_grad_add ::+          forall args . Fullfilled "_grad_add(ndarray)" args =>+            ArgsHMap "_grad_add(ndarray)" args -> IO [NDArrayHandle]+_grad_add args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_grad_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_grad_add_upd ::+              forall args . Fullfilled "_grad_add(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "_grad_add(ndarray)" args -> IO ()+_grad_add_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_grad_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_add(ndarray)" = '[]++_backward_add ::+              forall args . Fullfilled "_backward_add(ndarray)" args =>+                ArgsHMap "_backward_add(ndarray)" args -> IO [NDArrayHandle]+_backward_add args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_add_upd ::+                  forall args . Fullfilled "_backward_add(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_add(ndarray)" args -> IO ()+_backward_add_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "elemwise_sub(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++elemwise_sub ::+             forall args . Fullfilled "elemwise_sub(ndarray)" args =>+               ArgsHMap "elemwise_sub(ndarray)" args -> IO [NDArrayHandle]+elemwise_sub args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_sub"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++elemwise_sub_upd ::+                 forall args . Fullfilled "elemwise_sub(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "elemwise_sub(ndarray)" args -> IO ()+elemwise_sub_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_sub"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_sub(ndarray)" = '[]++_backward_sub ::+              forall args . Fullfilled "_backward_sub(ndarray)" args =>+                ArgsHMap "_backward_sub(ndarray)" args -> IO [NDArrayHandle]+_backward_sub args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sub"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_sub_upd ::+                  forall args . Fullfilled "_backward_sub(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_sub(ndarray)" args -> IO ()+_backward_sub_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sub"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "elemwise_mul(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++elemwise_mul ::+             forall args . Fullfilled "elemwise_mul(ndarray)" args =>+               ArgsHMap "elemwise_mul(ndarray)" args -> IO [NDArrayHandle]+elemwise_mul args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_mul"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++elemwise_mul_upd ::+                 forall args . Fullfilled "elemwise_mul(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "elemwise_mul(ndarray)" args -> IO ()+elemwise_mul_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_mul"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_mul(ndarray)" = '[]++_backward_mul ::+              forall args . Fullfilled "_backward_mul(ndarray)" args =>+                ArgsHMap "_backward_mul(ndarray)" args -> IO [NDArrayHandle]+_backward_mul args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mul"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_mul_upd ::+                  forall args . Fullfilled "_backward_mul(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_mul(ndarray)" args -> IO ()+_backward_mul_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mul"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "elemwise_div(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++elemwise_div ::+             forall args . Fullfilled "elemwise_div(ndarray)" args =>+               ArgsHMap "elemwise_div(ndarray)" args -> IO [NDArrayHandle]+elemwise_div args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++elemwise_div_upd ::+                 forall args . Fullfilled "elemwise_div(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "elemwise_div(ndarray)" args -> IO ()+elemwise_div_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_div(ndarray)" = '[]++_backward_div ::+              forall args . Fullfilled "_backward_div(ndarray)" args =>+                ArgsHMap "_backward_div(ndarray)" args -> IO [NDArrayHandle]+_backward_div args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_div_upd ::+                  forall args . Fullfilled "_backward_div(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_div(ndarray)" args -> IO ()+_backward_div_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_mod(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_mod ::+     forall args . Fullfilled "_mod(ndarray)" args =>+       ArgsHMap "_mod(ndarray)" args -> IO [NDArrayHandle]+_mod args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_mod_upd ::+         forall args . Fullfilled "_mod(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "_mod(ndarray)" args -> IO ()+_mod_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_mod(ndarray)" = '[]++_backward_mod ::+              forall args . Fullfilled "_backward_mod(ndarray)" args =>+                ArgsHMap "_backward_mod(ndarray)" args -> IO [NDArrayHandle]+_backward_mod args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_mod_upd ::+                  forall args . Fullfilled "_backward_mod(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_mod(ndarray)" args -> IO ()+_backward_mod_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_scatter_elemwise_div(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_scatter_elemwise_div ::+                      forall args . Fullfilled "_scatter_elemwise_div(ndarray)" args =>+                        ArgsHMap "_scatter_elemwise_div(ndarray)" args ->+                          IO [NDArrayHandle]+_scatter_elemwise_div args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_elemwise_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_scatter_elemwise_div_upd ::+                          forall args . Fullfilled "_scatter_elemwise_div(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_scatter_elemwise_div(ndarray)" args -> IO ()+_scatter_elemwise_div_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_elemwise_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_scatter_plus_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_scatter_plus_scalar ::+                     forall args . Fullfilled "_scatter_plus_scalar(ndarray)" args =>+                       ArgsHMap "_scatter_plus_scalar(ndarray)" args -> IO [NDArrayHandle]+_scatter_plus_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_plus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_scatter_plus_scalar_upd ::+                         forall args . Fullfilled "_scatter_plus_scalar(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_scatter_plus_scalar(ndarray)" args -> IO ()+_scatter_plus_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_plus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_scatter_minus_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_scatter_minus_scalar ::+                      forall args . Fullfilled "_scatter_minus_scalar(ndarray)" args =>+                        ArgsHMap "_scatter_minus_scalar(ndarray)" args ->+                          IO [NDArrayHandle]+_scatter_minus_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_minus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_scatter_minus_scalar_upd ::+                          forall args . Fullfilled "_scatter_minus_scalar(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_scatter_minus_scalar(ndarray)" args -> IO ()+_scatter_minus_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_minus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Embedding(ndarray)" =+     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("sparse_grad", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),+        '("weight", AttrOpt NDArrayHandle)]++_Embedding ::+           forall args . Fullfilled "_Embedding(ndarray)" args =>+             ArgsHMap "_Embedding(ndarray)" args -> IO [NDArrayHandle]+_Embedding args+  = let scalarArgs+          = catMaybes+              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"])),+               ("sparse_grad",) . showValue <$>+                 (args !? #sparse_grad :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Embedding"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Embedding_upd ::+               forall args . Fullfilled "_Embedding(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "_Embedding(ndarray)" args -> IO ()+_Embedding_upd outputs args+  = let scalarArgs+          = catMaybes+              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"])),+               ("sparse_grad",) . showValue <$>+                 (args !? #sparse_grad :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Embedding"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_SparseEmbedding(ndarray)" =+     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("sparse_grad", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),+        '("weight", AttrOpt NDArrayHandle)]++_contrib_SparseEmbedding ::+                         forall args .+                           Fullfilled "_contrib_SparseEmbedding(ndarray)" args =>+                           ArgsHMap "_contrib_SparseEmbedding(ndarray)" args ->+                             IO [NDArrayHandle]+_contrib_SparseEmbedding args+  = let scalarArgs+          = catMaybes+              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"])),+               ("sparse_grad",) . showValue <$>+                 (args !? #sparse_grad :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_SparseEmbedding"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_SparseEmbedding_upd ::+                             forall args .+                               Fullfilled "_contrib_SparseEmbedding(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_contrib_SparseEmbedding(ndarray)" args -> IO ()+_contrib_SparseEmbedding_upd outputs args+  = let scalarArgs+          = catMaybes+              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"])),+               ("sparse_grad",) . showValue <$>+                 (args !? #sparse_grad :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_SparseEmbedding"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Embedding(ndarray)" = '[]++_backward_Embedding ::+                    forall args . Fullfilled "_backward_Embedding(ndarray)" args =>+                      ArgsHMap "_backward_Embedding(ndarray)" args -> IO [NDArrayHandle]+_backward_Embedding args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Embedding"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Embedding_upd ::+                        forall args . Fullfilled "_backward_Embedding(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_backward_Embedding(ndarray)" args -> IO ()+_backward_Embedding_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Embedding"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SparseEmbedding(ndarray)" =+     '[]++_backward_SparseEmbedding ::+                          forall args .+                            Fullfilled "_backward_SparseEmbedding(ndarray)" args =>+                            ArgsHMap "_backward_SparseEmbedding(ndarray)" args ->+                              IO [NDArrayHandle]+_backward_SparseEmbedding args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SparseEmbedding"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SparseEmbedding_upd ::+                              forall args .+                                Fullfilled "_backward_SparseEmbedding(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_backward_SparseEmbedding(ndarray)" args -> IO ()+_backward_SparseEmbedding_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SparseEmbedding"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "take(ndarray)" =+     '[ '("axis", AttrOpt Int),+        '("mode", AttrOpt (EnumType '["clip", "raise", "wrap"])),+        '("a", AttrOpt NDArrayHandle), '("indices", AttrOpt NDArrayHandle)]++take ::+     forall args . Fullfilled "take(ndarray)" args =>+       ArgsHMap "take(ndarray)" args -> IO [NDArrayHandle]+take args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))]+        tensorArgs+          = catMaybes+              [("a",) <$> (args !? #a :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "take"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++take_upd ::+         forall args . Fullfilled "take(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "take(ndarray)" args -> IO ()+take_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))]+        tensorArgs+          = catMaybes+              [("a",) <$> (args !? #a :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "take"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_take(ndarray)" = '[]++_backward_take ::+               forall args . Fullfilled "_backward_take(ndarray)" args =>+                 ArgsHMap "_backward_take(ndarray)" args -> IO [NDArrayHandle]+_backward_take args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_take"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_take_upd ::+                   forall args . Fullfilled "_backward_take(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_take(ndarray)" args -> IO ()+_backward_take_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_take"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "batch_take(ndarray)" =+     '[ '("a", AttrOpt NDArrayHandle),+        '("indices", AttrOpt NDArrayHandle)]++batch_take ::+           forall args . Fullfilled "batch_take(ndarray)" args =>+             ArgsHMap "batch_take(ndarray)" args -> IO [NDArrayHandle]+batch_take args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("a",) <$> (args !? #a :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "batch_take"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++batch_take_upd ::+               forall args . Fullfilled "batch_take(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "batch_take(ndarray)" args -> IO ()+batch_take_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("a",) <$> (args !? #a :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "batch_take"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "one_hot(ndarray)" =+     '[ '("depth", AttrReq Int), '("on_value", AttrOpt Double),+        '("off_value", AttrOpt Double),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("indices", AttrOpt NDArrayHandle)]++one_hot ::+        forall args . Fullfilled "one_hot(ndarray)" args =>+          ArgsHMap "one_hot(ndarray)" args -> IO [NDArrayHandle]+one_hot args+  = let scalarArgs+          = catMaybes+              [("depth",) . showValue <$> (args !? #depth :: Maybe Int),+               ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double),+               ("off_value",) . showValue <$>+                 (args !? #off_value :: Maybe Double),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs+          = catMaybes+              [("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "one_hot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++one_hot_upd ::+            forall args . Fullfilled "one_hot(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "one_hot(ndarray)" args -> IO ()+one_hot_upd outputs args+  = let scalarArgs+          = catMaybes+              [("depth",) . showValue <$> (args !? #depth :: Maybe Int),+               ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double),+               ("off_value",) . showValue <$>+                 (args !? #off_value :: Maybe Double),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs+          = catMaybes+              [("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "one_hot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "gather_nd(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle),+        '("indices", AttrOpt NDArrayHandle)]++gather_nd ::+          forall args . Fullfilled "gather_nd(ndarray)" args =>+            ArgsHMap "gather_nd(ndarray)" args -> IO [NDArrayHandle]+gather_nd args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gather_nd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++gather_nd_upd ::+              forall args . Fullfilled "gather_nd(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "gather_nd(ndarray)" args -> IO ()+gather_nd_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gather_nd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "scatter_nd(ndarray)" =+     '[ '("shape", AttrReq [Int]), '("data", AttrOpt NDArrayHandle),+        '("indices", AttrOpt NDArrayHandle)]++scatter_nd ::+           forall args . Fullfilled "scatter_nd(ndarray)" args =>+             ArgsHMap "scatter_nd(ndarray)" args -> IO [NDArrayHandle]+scatter_nd args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "scatter_nd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++scatter_nd_upd ::+               forall args . Fullfilled "scatter_nd(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "scatter_nd(ndarray)" args -> IO ()+scatter_nd_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "scatter_nd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_gather_nd(ndarray)" =+     '[ '("shape", AttrReq [Int]), '("data", AttrOpt NDArrayHandle),+        '("indices", AttrOpt NDArrayHandle)]++_backward_gather_nd ::+                    forall args . Fullfilled "_backward_gather_nd(ndarray)" args =>+                      ArgsHMap "_backward_gather_nd(ndarray)" args -> IO [NDArrayHandle]+_backward_gather_nd args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_gather_nd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_gather_nd_upd ::+                        forall args . Fullfilled "_backward_gather_nd(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_backward_gather_nd(ndarray)" args -> IO ()+_backward_gather_nd_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_gather_nd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_scatter_set_nd(ndarray)" =+     '[ '("shape", AttrReq [Int]), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle),+        '("indices", AttrOpt NDArrayHandle)]++_scatter_set_nd ::+                forall args . Fullfilled "_scatter_set_nd(ndarray)" args =>+                  ArgsHMap "_scatter_set_nd(ndarray)" args -> IO [NDArrayHandle]+_scatter_set_nd args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_set_nd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_scatter_set_nd_upd ::+                    forall args . Fullfilled "_scatter_set_nd(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_scatter_set_nd(ndarray)" args -> IO ()+_scatter_set_nd_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_set_nd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_equal(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_equal ::+                forall args . Fullfilled "broadcast_equal(ndarray)" args =>+                  ArgsHMap "broadcast_equal(ndarray)" args -> IO [NDArrayHandle]+broadcast_equal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_equal_upd ::+                    forall args . Fullfilled "broadcast_equal(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "broadcast_equal(ndarray)" args -> IO ()+broadcast_equal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_not_equal(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_not_equal ::+                    forall args . Fullfilled "broadcast_not_equal(ndarray)" args =>+                      ArgsHMap "broadcast_not_equal(ndarray)" args -> IO [NDArrayHandle]+broadcast_not_equal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_not_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_not_equal_upd ::+                        forall args . Fullfilled "broadcast_not_equal(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "broadcast_not_equal(ndarray)" args -> IO ()+broadcast_not_equal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_not_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_greater(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_greater ::+                  forall args . Fullfilled "broadcast_greater(ndarray)" args =>+                    ArgsHMap "broadcast_greater(ndarray)" args -> IO [NDArrayHandle]+broadcast_greater args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_greater"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_greater_upd ::+                      forall args . Fullfilled "broadcast_greater(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "broadcast_greater(ndarray)" args -> IO ()+broadcast_greater_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_greater"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_greater_equal(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_greater_equal ::+                        forall args . Fullfilled "broadcast_greater_equal(ndarray)" args =>+                          ArgsHMap "broadcast_greater_equal(ndarray)" args ->+                            IO [NDArrayHandle]+broadcast_greater_equal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_greater_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_greater_equal_upd ::+                            forall args . Fullfilled "broadcast_greater_equal(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "broadcast_greater_equal(ndarray)" args -> IO ()+broadcast_greater_equal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_greater_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_lesser(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_lesser ::+                 forall args . Fullfilled "broadcast_lesser(ndarray)" args =>+                   ArgsHMap "broadcast_lesser(ndarray)" args -> IO [NDArrayHandle]+broadcast_lesser args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_lesser"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_lesser_upd ::+                     forall args . Fullfilled "broadcast_lesser(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "broadcast_lesser(ndarray)" args -> IO ()+broadcast_lesser_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_lesser"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_lesser_equal(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_lesser_equal ::+                       forall args . Fullfilled "broadcast_lesser_equal(ndarray)" args =>+                         ArgsHMap "broadcast_lesser_equal(ndarray)" args ->+                           IO [NDArrayHandle]+broadcast_lesser_equal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_lesser_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_lesser_equal_upd ::+                           forall args . Fullfilled "broadcast_lesser_equal(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "broadcast_lesser_equal(ndarray)" args -> IO ()+broadcast_lesser_equal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_lesser_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_logical_and(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_logical_and ::+                      forall args . Fullfilled "broadcast_logical_and(ndarray)" args =>+                        ArgsHMap "broadcast_logical_and(ndarray)" args ->+                          IO [NDArrayHandle]+broadcast_logical_and args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_logical_and"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_logical_and_upd ::+                          forall args . Fullfilled "broadcast_logical_and(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "broadcast_logical_and(ndarray)" args -> IO ()+broadcast_logical_and_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_logical_and"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_logical_or(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_logical_or ::+                     forall args . Fullfilled "broadcast_logical_or(ndarray)" args =>+                       ArgsHMap "broadcast_logical_or(ndarray)" args -> IO [NDArrayHandle]+broadcast_logical_or args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_logical_or"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_logical_or_upd ::+                         forall args . Fullfilled "broadcast_logical_or(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "broadcast_logical_or(ndarray)" args -> IO ()+broadcast_logical_or_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_logical_or"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_logical_xor(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_logical_xor ::+                      forall args . Fullfilled "broadcast_logical_xor(ndarray)" args =>+                        ArgsHMap "broadcast_logical_xor(ndarray)" args ->+                          IO [NDArrayHandle]+broadcast_logical_xor args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_logical_xor"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_logical_xor_upd ::+                          forall args . Fullfilled "broadcast_logical_xor(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "broadcast_logical_xor(ndarray)" args -> IO ()+broadcast_logical_xor_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_logical_xor"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_plus_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_plus_scalar ::+             forall args . Fullfilled "_plus_scalar(ndarray)" args =>+               ArgsHMap "_plus_scalar(ndarray)" args -> IO [NDArrayHandle]+_plus_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_plus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_plus_scalar_upd ::+                 forall args . Fullfilled "_plus_scalar(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_plus_scalar(ndarray)" args -> IO ()+_plus_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_plus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_minus_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_minus_scalar ::+              forall args . Fullfilled "_minus_scalar(ndarray)" args =>+                ArgsHMap "_minus_scalar(ndarray)" args -> IO [NDArrayHandle]+_minus_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_minus_scalar_upd ::+                  forall args . Fullfilled "_minus_scalar(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_minus_scalar(ndarray)" args -> IO ()+_minus_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_rminus_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_rminus_scalar ::+               forall args . Fullfilled "_rminus_scalar(ndarray)" args =>+                 ArgsHMap "_rminus_scalar(ndarray)" args -> IO [NDArrayHandle]+_rminus_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rminus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_rminus_scalar_upd ::+                   forall args . Fullfilled "_rminus_scalar(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_rminus_scalar(ndarray)" args -> IO ()+_rminus_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rminus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_mul_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_mul_scalar ::+            forall args . Fullfilled "_mul_scalar(ndarray)" args =>+              ArgsHMap "_mul_scalar(ndarray)" args -> IO [NDArrayHandle]+_mul_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mul_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_mul_scalar_upd ::+                forall args . Fullfilled "_mul_scalar(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_mul_scalar(ndarray)" args -> IO ()+_mul_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mul_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_mul_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_backward_mul_scalar ::+                     forall args . Fullfilled "_backward_mul_scalar(ndarray)" args =>+                       ArgsHMap "_backward_mul_scalar(ndarray)" args -> IO [NDArrayHandle]+_backward_mul_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mul_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_mul_scalar_upd ::+                         forall args . Fullfilled "_backward_mul_scalar(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_mul_scalar(ndarray)" args -> IO ()+_backward_mul_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mul_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_div_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_div_scalar ::+            forall args . Fullfilled "_div_scalar(ndarray)" args =>+              ArgsHMap "_div_scalar(ndarray)" args -> IO [NDArrayHandle]+_div_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_div_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_div_scalar_upd ::+                forall args . Fullfilled "_div_scalar(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_div_scalar(ndarray)" args -> IO ()+_div_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_div_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_div_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_backward_div_scalar ::+                     forall args . Fullfilled "_backward_div_scalar(ndarray)" args =>+                       ArgsHMap "_backward_div_scalar(ndarray)" args -> IO [NDArrayHandle]+_backward_div_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_div_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_div_scalar_upd ::+                         forall args . Fullfilled "_backward_div_scalar(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_div_scalar(ndarray)" args -> IO ()+_backward_div_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_div_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_rdiv_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_rdiv_scalar ::+             forall args . Fullfilled "_rdiv_scalar(ndarray)" args =>+               ArgsHMap "_rdiv_scalar(ndarray)" args -> IO [NDArrayHandle]+_rdiv_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rdiv_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_rdiv_scalar_upd ::+                 forall args . Fullfilled "_rdiv_scalar(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_rdiv_scalar(ndarray)" args -> IO ()+_rdiv_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rdiv_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_rdiv_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_rdiv_scalar ::+                      forall args . Fullfilled "_backward_rdiv_scalar(ndarray)" args =>+                        ArgsHMap "_backward_rdiv_scalar(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_rdiv_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rdiv_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_rdiv_scalar_upd ::+                          forall args . Fullfilled "_backward_rdiv_scalar(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_rdiv_scalar(ndarray)" args -> IO ()+_backward_rdiv_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rdiv_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_mod_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_mod_scalar ::+            forall args . Fullfilled "_mod_scalar(ndarray)" args =>+              ArgsHMap "_mod_scalar(ndarray)" args -> IO [NDArrayHandle]+_mod_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mod_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_mod_scalar_upd ::+                forall args . Fullfilled "_mod_scalar(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_mod_scalar(ndarray)" args -> IO ()+_mod_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mod_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_mod_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_mod_scalar ::+                     forall args . Fullfilled "_backward_mod_scalar(ndarray)" args =>+                       ArgsHMap "_backward_mod_scalar(ndarray)" args -> IO [NDArrayHandle]+_backward_mod_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mod_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_mod_scalar_upd ::+                         forall args . Fullfilled "_backward_mod_scalar(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_mod_scalar(ndarray)" args -> IO ()+_backward_mod_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mod_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_rmod_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_rmod_scalar ::+             forall args . Fullfilled "_rmod_scalar(ndarray)" args =>+               ArgsHMap "_rmod_scalar(ndarray)" args -> IO [NDArrayHandle]+_rmod_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rmod_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_rmod_scalar_upd ::+                 forall args . Fullfilled "_rmod_scalar(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_rmod_scalar(ndarray)" args -> IO ()+_rmod_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rmod_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_rmod_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_rmod_scalar ::+                      forall args . Fullfilled "_backward_rmod_scalar(ndarray)" args =>+                        ArgsHMap "_backward_rmod_scalar(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_rmod_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rmod_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_rmod_scalar_upd ::+                          forall args . Fullfilled "_backward_rmod_scalar(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_rmod_scalar(ndarray)" args -> IO ()+_backward_rmod_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rmod_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_ravel_multi_index(ndarray)" =+     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]++_ravel_multi_index ::+                   forall args . Fullfilled "_ravel_multi_index(ndarray)" args =>+                     ArgsHMap "_ravel_multi_index(ndarray)" args -> IO [NDArrayHandle]+_ravel_multi_index args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_ravel_multi_index"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_ravel_multi_index_upd ::+                       forall args . Fullfilled "_ravel_multi_index(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_ravel_multi_index(ndarray)" args -> IO ()+_ravel_multi_index_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_ravel_multi_index"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_unravel_index(ndarray)" =+     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]++_unravel_index ::+               forall args . Fullfilled "_unravel_index(ndarray)" args =>+                 ArgsHMap "_unravel_index(ndarray)" args -> IO [NDArrayHandle]+_unravel_index args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_unravel_index"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_unravel_index_upd ::+                   forall args . Fullfilled "_unravel_index(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_unravel_index(ndarray)" args -> IO ()+_unravel_index_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_unravel_index"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "argmax(ndarray)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),+        '("data", AttrOpt NDArrayHandle)]++argmax ::+       forall args . Fullfilled "argmax(ndarray)" args =>+         ArgsHMap "argmax(ndarray)" args -> IO [NDArrayHandle]+argmax args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++argmax_upd ::+           forall args . Fullfilled "argmax(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "argmax(ndarray)" args -> IO ()+argmax_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "argmin(ndarray)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),+        '("data", AttrOpt NDArrayHandle)]++argmin ::+       forall args . Fullfilled "argmin(ndarray)" args =>+         ArgsHMap "argmin(ndarray)" args -> IO [NDArrayHandle]+argmin args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++argmin_upd ::+           forall args . Fullfilled "argmin(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "argmin(ndarray)" args -> IO ()+argmin_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "argmax_channel(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++argmax_channel ::+               forall args . Fullfilled "argmax_channel(ndarray)" args =>+                 ArgsHMap "argmax_channel(ndarray)" args -> IO [NDArrayHandle]+argmax_channel args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmax_channel"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++argmax_channel_upd ::+                   forall args . Fullfilled "argmax_channel(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "argmax_channel(ndarray)" args -> IO ()+argmax_channel_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmax_channel"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "pick(ndarray)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),+        '("mode", AttrOpt (EnumType '["clip", "wrap"])),+        '("data", AttrOpt NDArrayHandle),+        '("index", AttrOpt NDArrayHandle)]++pick ::+     forall args . Fullfilled "pick(ndarray)" args =>+       ArgsHMap "pick(ndarray)" args -> IO [NDArrayHandle]+pick args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["clip", "wrap"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("index",) <$> (args !? #index :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "pick"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++pick_upd ::+         forall args . Fullfilled "pick(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "pick(ndarray)" args -> IO ()+pick_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["clip", "wrap"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("index",) <$> (args !? #index :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "pick"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_pick(ndarray)" = '[]++_backward_pick ::+               forall args . Fullfilled "_backward_pick(ndarray)" args =>+                 ArgsHMap "_backward_pick(ndarray)" args -> IO [NDArrayHandle]+_backward_pick args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_pick"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_pick_upd ::+                   forall args . Fullfilled "_backward_pick(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_pick(ndarray)" args -> IO ()+_backward_pick_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_pick"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_sparse_retain(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle),+        '("indices", AttrOpt NDArrayHandle)]++_sparse_retain ::+               forall args . Fullfilled "_sparse_retain(ndarray)" args =>+                 ArgsHMap "_sparse_retain(ndarray)" args -> IO [NDArrayHandle]+_sparse_retain args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sparse_retain"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sparse_retain_upd ::+                   forall args . Fullfilled "_sparse_retain(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_sparse_retain(ndarray)" args -> IO ()+_sparse_retain_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sparse_retain"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_sparse_retain(ndarray)" =+     '[]++_backward_sparse_retain ::+                        forall args . Fullfilled "_backward_sparse_retain(ndarray)" args =>+                          ArgsHMap "_backward_sparse_retain(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_sparse_retain args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sparse_retain"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_sparse_retain_upd ::+                            forall args . Fullfilled "_backward_sparse_retain(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_sparse_retain(ndarray)" args -> IO ()+_backward_sparse_retain_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sparse_retain"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_where(ndarray)" =+     '[ '("condition", AttrOpt NDArrayHandle),+        '("x", AttrOpt NDArrayHandle), '("y", AttrOpt NDArrayHandle)]++_where ::+       forall args . Fullfilled "_where(ndarray)" args =>+         ArgsHMap "_where(ndarray)" args -> IO [NDArrayHandle]+_where args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("condition",) <$> (args !? #condition :: Maybe NDArrayHandle),+               ("x",) <$> (args !? #x :: Maybe NDArrayHandle),+               ("y",) <$> (args !? #y :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "where"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_where_upd ::+           forall args . Fullfilled "_where(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "_where(ndarray)" args -> IO ()+_where_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("condition",) <$> (args !? #condition :: Maybe NDArrayHandle),+               ("x",) <$> (args !? #x :: Maybe NDArrayHandle),+               ("y",) <$> (args !? #y :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "where"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_where(ndarray)" = '[]++_backward_where ::+                forall args . Fullfilled "_backward_where(ndarray)" args =>+                  ArgsHMap "_backward_where(ndarray)" args -> IO [NDArrayHandle]+_backward_where args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_where"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_where_upd ::+                    forall args . Fullfilled "_backward_where(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_where(ndarray)" args -> IO ()+_backward_where_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_where"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "diag(ndarray)" =+     '[ '("k", AttrOpt Int), '("axis1", AttrOpt Int),+        '("axis2", AttrOpt Int), '("data", AttrOpt NDArrayHandle)]++diag ::+     forall args . Fullfilled "diag(ndarray)" args =>+       ArgsHMap "diag(ndarray)" args -> IO [NDArrayHandle]+diag args+  = let scalarArgs+          = catMaybes+              [("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("axis1",) . showValue <$> (args !? #axis1 :: Maybe Int),+               ("axis2",) . showValue <$> (args !? #axis2 :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "diag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++diag_upd ::+         forall args . Fullfilled "diag(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "diag(ndarray)" args -> IO ()+diag_upd outputs args+  = let scalarArgs+          = catMaybes+              [("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("axis1",) . showValue <$> (args !? #axis1 :: Maybe Int),+               ("axis2",) . showValue <$> (args !? #axis2 :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "diag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_diag(ndarray)" = '[]++_backward_diag ::+               forall args . Fullfilled "_backward_diag(ndarray)" args =>+                 ArgsHMap "_backward_diag(ndarray)" args -> IO [NDArrayHandle]+_backward_diag args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_diag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_diag_upd ::+                   forall args . Fullfilled "_backward_diag(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_diag(ndarray)" args -> IO ()+_backward_diag_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_diag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_maximum_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_maximum_scalar ::+                forall args . Fullfilled "_maximum_scalar(ndarray)" args =>+                  ArgsHMap "_maximum_scalar(ndarray)" args -> IO [NDArrayHandle]+_maximum_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_maximum_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_maximum_scalar_upd ::+                    forall args . Fullfilled "_maximum_scalar(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_maximum_scalar(ndarray)" args -> IO ()+_maximum_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_maximum_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_maximum_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_maximum_scalar ::+                         forall args .+                           Fullfilled "_backward_maximum_scalar(ndarray)" args =>+                           ArgsHMap "_backward_maximum_scalar(ndarray)" args ->+                             IO [NDArrayHandle]+_backward_maximum_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_maximum_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_maximum_scalar_upd ::+                             forall args .+                               Fullfilled "_backward_maximum_scalar(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_backward_maximum_scalar(ndarray)" args -> IO ()+_backward_maximum_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_maximum_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_minimum_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_minimum_scalar ::+                forall args . Fullfilled "_minimum_scalar(ndarray)" args =>+                  ArgsHMap "_minimum_scalar(ndarray)" args -> IO [NDArrayHandle]+_minimum_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minimum_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_minimum_scalar_upd ::+                    forall args . Fullfilled "_minimum_scalar(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_minimum_scalar(ndarray)" args -> IO ()+_minimum_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minimum_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_minimum_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_minimum_scalar ::+                         forall args .+                           Fullfilled "_backward_minimum_scalar(ndarray)" args =>+                           ArgsHMap "_backward_minimum_scalar(ndarray)" args ->+                             IO [NDArrayHandle]+_backward_minimum_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_minimum_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_minimum_scalar_upd ::+                             forall args .+                               Fullfilled "_backward_minimum_scalar(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_backward_minimum_scalar(ndarray)" args -> IO ()+_backward_minimum_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_minimum_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_power_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_power_scalar ::+              forall args . Fullfilled "_power_scalar(ndarray)" args =>+                ArgsHMap "_power_scalar(ndarray)" args -> IO [NDArrayHandle]+_power_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_power_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_power_scalar_upd ::+                  forall args . Fullfilled "_power_scalar(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_power_scalar(ndarray)" args -> IO ()+_power_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_power_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_power_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_power_scalar ::+                       forall args . Fullfilled "_backward_power_scalar(ndarray)" args =>+                         ArgsHMap "_backward_power_scalar(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_power_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_power_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_power_scalar_upd ::+                           forall args . Fullfilled "_backward_power_scalar(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_power_scalar(ndarray)" args -> IO ()+_backward_power_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_power_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_rpower_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_rpower_scalar ::+               forall args . Fullfilled "_rpower_scalar(ndarray)" args =>+                 ArgsHMap "_rpower_scalar(ndarray)" args -> IO [NDArrayHandle]+_rpower_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rpower_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_rpower_scalar_upd ::+                   forall args . Fullfilled "_rpower_scalar(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_rpower_scalar(ndarray)" args -> IO ()+_rpower_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rpower_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_rpower_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_rpower_scalar ::+                        forall args . Fullfilled "_backward_rpower_scalar(ndarray)" args =>+                          ArgsHMap "_backward_rpower_scalar(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_rpower_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rpower_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_rpower_scalar_upd ::+                            forall args . Fullfilled "_backward_rpower_scalar(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_rpower_scalar(ndarray)" args -> IO ()+_backward_rpower_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rpower_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_hypot_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_hypot_scalar ::+              forall args . Fullfilled "_hypot_scalar(ndarray)" args =>+                ArgsHMap "_hypot_scalar(ndarray)" args -> IO [NDArrayHandle]+_hypot_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_hypot_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_hypot_scalar_upd ::+                  forall args . Fullfilled "_hypot_scalar(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_hypot_scalar(ndarray)" args -> IO ()+_hypot_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_hypot_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_hypot_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_hypot_scalar ::+                       forall args . Fullfilled "_backward_hypot_scalar(ndarray)" args =>+                         ArgsHMap "_backward_hypot_scalar(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_hypot_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_hypot_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_hypot_scalar_upd ::+                           forall args . Fullfilled "_backward_hypot_scalar(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_hypot_scalar(ndarray)" args -> IO ()+_backward_hypot_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_hypot_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "smooth_l1(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++smooth_l1 ::+          forall args . Fullfilled "smooth_l1(ndarray)" args =>+            ArgsHMap "smooth_l1(ndarray)" args -> IO [NDArrayHandle]+smooth_l1 args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "smooth_l1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++smooth_l1_upd ::+              forall args . Fullfilled "smooth_l1(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "smooth_l1(ndarray)" args -> IO ()+smooth_l1_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "smooth_l1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_smooth_l1(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_smooth_l1 ::+                    forall args . Fullfilled "_backward_smooth_l1(ndarray)" args =>+                      ArgsHMap "_backward_smooth_l1(ndarray)" args -> IO [NDArrayHandle]+_backward_smooth_l1 args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_smooth_l1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_smooth_l1_upd ::+                        forall args . Fullfilled "_backward_smooth_l1(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_backward_smooth_l1(ndarray)" args -> IO ()+_backward_smooth_l1_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_smooth_l1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "topk(ndarray)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("k", AttrOpt Int),+        '("ret_typ",+          AttrOpt (EnumType '["both", "indices", "mask", "value"])),+        '("is_ascend", AttrOpt Bool),+        '("dtype",+          AttrOpt+            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),+        '("data", AttrOpt NDArrayHandle)]++topk ::+     forall args . Fullfilled "topk(ndarray)" args =>+       ArgsHMap "topk(ndarray)" args -> IO [NDArrayHandle]+topk args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("ret_typ",) . showValue <$>+                 (args !? #ret_typ ::+                    Maybe (EnumType '["both", "indices", "mask", "value"])),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "topk"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++topk_upd ::+         forall args . Fullfilled "topk(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "topk(ndarray)" args -> IO ()+topk_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("ret_typ",) . showValue <$>+                 (args !? #ret_typ ::+                    Maybe (EnumType '["both", "indices", "mask", "value"])),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "topk"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_topk(ndarray)" = '[]++_backward_topk ::+               forall args . Fullfilled "_backward_topk(ndarray)" args =>+                 ArgsHMap "_backward_topk(ndarray)" args -> IO [NDArrayHandle]+_backward_topk args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_topk"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_topk_upd ::+                   forall args . Fullfilled "_backward_topk(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_topk(ndarray)" args -> IO ()+_backward_topk_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_topk"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "sort(ndarray)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),+        '("data", AttrOpt NDArrayHandle)]++sort ::+     forall args . Fullfilled "sort(ndarray)" args =>+       ArgsHMap "sort(ndarray)" args -> IO [NDArrayHandle]+sort args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sort"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++sort_upd ::+         forall args . Fullfilled "sort(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "sort(ndarray)" args -> IO ()+sort_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sort"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "argsort(ndarray)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),+        '("dtype",+          AttrOpt+            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),+        '("data", AttrOpt NDArrayHandle)]++argsort ::+        forall args . Fullfilled "argsort(ndarray)" args =>+          ArgsHMap "argsort(ndarray)" args -> IO [NDArrayHandle]+argsort args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argsort"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++argsort_upd ::+            forall args . Fullfilled "argsort(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "argsort(ndarray)" args -> IO ()+argsort_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argsort"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Reshape(ndarray)" =+     '[ '("shape", AttrOpt [Int]), '("reverse", AttrOpt Bool),+        '("target_shape", AttrOpt [Int]), '("keep_highest", AttrOpt Bool),+        '("data", AttrOpt NDArrayHandle)]++_Reshape ::+         forall args . Fullfilled "_Reshape(ndarray)" args =>+           ArgsHMap "_Reshape(ndarray)" args -> IO [NDArrayHandle]+_Reshape args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("keep_highest",) . showValue <$>+                 (args !? #keep_highest :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Reshape"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Reshape_upd ::+             forall args . Fullfilled "_Reshape(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "_Reshape(ndarray)" args -> IO ()+_Reshape_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("keep_highest",) . showValue <$>+                 (args !? #keep_highest :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Reshape"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Flatten(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_Flatten ::+         forall args . Fullfilled "_Flatten(ndarray)" args =>+           ArgsHMap "_Flatten(ndarray)" args -> IO [NDArrayHandle]+_Flatten args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Flatten"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Flatten_upd ::+             forall args . Fullfilled "_Flatten(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "_Flatten(ndarray)" args -> IO ()+_Flatten_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Flatten"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "transpose(ndarray)" =+     '[ '("axes", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]++transpose ::+          forall args . Fullfilled "transpose(ndarray)" args =>+            ArgsHMap "transpose(ndarray)" args -> IO [NDArrayHandle]+transpose args+  = let scalarArgs+          = catMaybes+              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "transpose"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++transpose_upd ::+              forall args . Fullfilled "transpose(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "transpose(ndarray)" args -> IO ()+transpose_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "transpose"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "expand_dims(ndarray)" =+     '[ '("axis", AttrReq Int), '("data", AttrOpt NDArrayHandle)]++expand_dims ::+            forall args . Fullfilled "expand_dims(ndarray)" args =>+              ArgsHMap "expand_dims(ndarray)" args -> IO [NDArrayHandle]+expand_dims args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "expand_dims"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++expand_dims_upd ::+                forall args . Fullfilled "expand_dims(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "expand_dims(ndarray)" args -> IO ()+expand_dims_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "expand_dims"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "slice(ndarray)" =+     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),+        '("step", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]++slice ::+      forall args . Fullfilled "slice(ndarray)" args =>+        ArgsHMap "slice(ndarray)" args -> IO [NDArrayHandle]+slice args+  = let scalarArgs+          = catMaybes+              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "slice"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++slice_upd ::+          forall args . Fullfilled "slice(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "slice(ndarray)" args -> IO ()+slice_upd outputs args+  = let scalarArgs+          = catMaybes+              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "slice"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_slice(ndarray)" = '[]++_backward_slice ::+                forall args . Fullfilled "_backward_slice(ndarray)" args =>+                  ArgsHMap "_backward_slice(ndarray)" args -> IO [NDArrayHandle]+_backward_slice args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_slice"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_slice_upd ::+                    forall args . Fullfilled "_backward_slice(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_slice(ndarray)" args -> IO ()+_backward_slice_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_slice"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_slice_assign(ndarray)" =+     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),+        '("step", AttrOpt [Int]), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_slice_assign ::+              forall args . Fullfilled "_slice_assign(ndarray)" args =>+                ArgsHMap "_slice_assign(ndarray)" args -> IO [NDArrayHandle]+_slice_assign args+  = let scalarArgs+          = catMaybes+              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_slice_assign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_slice_assign_upd ::+                  forall args . Fullfilled "_slice_assign(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_slice_assign(ndarray)" args -> IO ()+_slice_assign_upd outputs args+  = let scalarArgs+          = catMaybes+              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_slice_assign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_slice_assign_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Double), '("begin", AttrReq [Int]),+        '("end", AttrReq [Int]), '("step", AttrOpt [Int]),+        '("data", AttrOpt NDArrayHandle)]++_slice_assign_scalar ::+                     forall args . Fullfilled "_slice_assign_scalar(ndarray)" args =>+                       ArgsHMap "_slice_assign_scalar(ndarray)" args -> IO [NDArrayHandle]+_slice_assign_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Double),+               ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_slice_assign_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_slice_assign_scalar_upd ::+                         forall args . Fullfilled "_slice_assign_scalar(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_slice_assign_scalar(ndarray)" args -> IO ()+_slice_assign_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Double),+               ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_slice_assign_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "slice_axis(ndarray)" =+     '[ '("axis", AttrReq Int), '("begin", AttrReq Int),+        '("end", AttrReq (Maybe Int)), '("data", AttrOpt NDArrayHandle)]++slice_axis ::+           forall args . Fullfilled "slice_axis(ndarray)" args =>+             ArgsHMap "slice_axis(ndarray)" args -> IO [NDArrayHandle]+slice_axis args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("begin",) . showValue <$> (args !? #begin :: Maybe Int),+               ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "slice_axis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++slice_axis_upd ::+               forall args . Fullfilled "slice_axis(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "slice_axis(ndarray)" args -> IO ()+slice_axis_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("begin",) . showValue <$> (args !? #begin :: Maybe Int),+               ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "slice_axis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_slice_axis(ndarray)" = '[]++_backward_slice_axis ::+                     forall args . Fullfilled "_backward_slice_axis(ndarray)" args =>+                       ArgsHMap "_backward_slice_axis(ndarray)" args -> IO [NDArrayHandle]+_backward_slice_axis args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_slice_axis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_slice_axis_upd ::+                         forall args . Fullfilled "_backward_slice_axis(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_slice_axis(ndarray)" args -> IO ()+_backward_slice_axis_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_slice_axis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "slice_like(ndarray)" =+     '[ '("axes", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle),+        '("shape_like", AttrOpt NDArrayHandle)]++slice_like ::+           forall args . Fullfilled "slice_like(ndarray)" args =>+             ArgsHMap "slice_like(ndarray)" args -> IO [NDArrayHandle]+slice_like args+  = let scalarArgs+          = catMaybes+              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("shape_like",) <$> (args !? #shape_like :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "slice_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++slice_like_upd ::+               forall args . Fullfilled "slice_like(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "slice_like(ndarray)" args -> IO ()+slice_like_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("shape_like",) <$> (args !? #shape_like :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "slice_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_slice_like(ndarray)" = '[]++_backward_slice_like ::+                     forall args . Fullfilled "_backward_slice_like(ndarray)" args =>+                       ArgsHMap "_backward_slice_like(ndarray)" args -> IO [NDArrayHandle]+_backward_slice_like args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_slice_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_slice_like_upd ::+                         forall args . Fullfilled "_backward_slice_like(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_slice_like(ndarray)" args -> IO ()+_backward_slice_like_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_slice_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "clip(ndarray)" =+     '[ '("a_min", AttrReq Float), '("a_max", AttrReq Float),+        '("data", AttrOpt NDArrayHandle)]++clip ::+     forall args . Fullfilled "clip(ndarray)" args =>+       ArgsHMap "clip(ndarray)" args -> IO [NDArrayHandle]+clip args+  = let scalarArgs+          = catMaybes+              [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float),+               ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "clip"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++clip_upd ::+         forall args . Fullfilled "clip(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "clip(ndarray)" args -> IO ()+clip_upd outputs args+  = let scalarArgs+          = catMaybes+              [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float),+               ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "clip"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_clip(ndarray)" = '[]++_backward_clip ::+               forall args . Fullfilled "_backward_clip(ndarray)" args =>+                 ArgsHMap "_backward_clip(ndarray)" args -> IO [NDArrayHandle]+_backward_clip args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_clip"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_clip_upd ::+                   forall args . Fullfilled "_backward_clip(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_clip(ndarray)" args -> IO ()+_backward_clip_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_clip"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "repeat(ndarray)" =+     '[ '("repeats", AttrReq Int), '("axis", AttrOpt (Maybe Int)),+        '("data", AttrOpt NDArrayHandle)]++repeat ::+       forall args . Fullfilled "repeat(ndarray)" args =>+         ArgsHMap "repeat(ndarray)" args -> IO [NDArrayHandle]+repeat args+  = let scalarArgs+          = catMaybes+              [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int),+               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "repeat"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++repeat_upd ::+           forall args . Fullfilled "repeat(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "repeat(ndarray)" args -> IO ()+repeat_upd outputs args+  = let scalarArgs+          = catMaybes+              [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int),+               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "repeat"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_repeat(ndarray)" = '[]++_backward_repeat ::+                 forall args . Fullfilled "_backward_repeat(ndarray)" args =>+                   ArgsHMap "_backward_repeat(ndarray)" args -> IO [NDArrayHandle]+_backward_repeat args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_repeat"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_repeat_upd ::+                     forall args . Fullfilled "_backward_repeat(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_backward_repeat(ndarray)" args -> IO ()+_backward_repeat_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_repeat"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "tile(ndarray)" =+     '[ '("reps", AttrReq [Int]), '("data", AttrOpt NDArrayHandle)]++tile ::+     forall args . Fullfilled "tile(ndarray)" args =>+       ArgsHMap "tile(ndarray)" args -> IO [NDArrayHandle]+tile args+  = let scalarArgs+          = catMaybes+              [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tile"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++tile_upd ::+         forall args . Fullfilled "tile(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "tile(ndarray)" args -> IO ()+tile_upd outputs args+  = let scalarArgs+          = catMaybes+              [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tile"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_tile(ndarray)" = '[]++_backward_tile ::+               forall args . Fullfilled "_backward_tile(ndarray)" args =>+                 ArgsHMap "_backward_tile(ndarray)" args -> IO [NDArrayHandle]+_backward_tile args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tile"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_tile_upd ::+                   forall args . Fullfilled "_backward_tile(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_tile(ndarray)" args -> IO ()+_backward_tile_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tile"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "reverse(ndarray)" =+     '[ '("axis", AttrReq [Int]), '("data", AttrOpt NDArrayHandle)]++reverse ::+        forall args . Fullfilled "reverse(ndarray)" args =>+          ArgsHMap "reverse(ndarray)" args -> IO [NDArrayHandle]+reverse args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reverse"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++reverse_upd ::+            forall args . Fullfilled "reverse(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "reverse(ndarray)" args -> IO ()+reverse_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reverse"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_reverse(ndarray)" = '[]++_backward_reverse ::+                  forall args . Fullfilled "_backward_reverse(ndarray)" args =>+                    ArgsHMap "_backward_reverse(ndarray)" args -> IO [NDArrayHandle]+_backward_reverse args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_reverse"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_reverse_upd ::+                      forall args . Fullfilled "_backward_reverse(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_reverse(ndarray)" args -> IO ()+_backward_reverse_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_reverse"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "stack(ndarray)" =+     '[ '("axis", AttrOpt Int), '("num_args", AttrReq Int),+        '("data", AttrOpt [NDArrayHandle])]++stack ::+      forall args . Fullfilled "stack(ndarray)" args =>+        ArgsHMap "stack(ndarray)" args -> IO [NDArrayHandle]+stack args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "stack"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        Nothing+         return listndarr++stack_upd ::+          forall args . Fullfilled "stack(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "stack(ndarray)" args -> IO ()+stack_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "stack"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        (Just outputs)+         return ()++type instance ParameterList "_backward_stack(ndarray)" = '[]++_backward_stack ::+                forall args . Fullfilled "_backward_stack(ndarray)" args =>+                  ArgsHMap "_backward_stack(ndarray)" args -> IO [NDArrayHandle]+_backward_stack args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_stack"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_stack_upd ::+                    forall args . Fullfilled "_backward_stack(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_stack(ndarray)" args -> IO ()+_backward_stack_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_stack"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "squeeze(ndarray)" =+     '[ '("axis", AttrOpt (Maybe [Int])),+        '("data", AttrOpt [NDArrayHandle])]++squeeze ::+        forall args . Fullfilled "squeeze(ndarray)" args =>+          ArgsHMap "squeeze(ndarray)" args -> IO [NDArrayHandle]+squeeze args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "squeeze"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++squeeze_upd ::+            forall args . Fullfilled "squeeze(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "squeeze(ndarray)" args -> IO ()+squeeze_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "squeeze"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_squeeze(ndarray)" = '[]++_backward_squeeze ::+                  forall args . Fullfilled "_backward_squeeze(ndarray)" args =>+                    ArgsHMap "_backward_squeeze(ndarray)" args -> IO [NDArrayHandle]+_backward_squeeze args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_squeeze"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_squeeze_upd ::+                      forall args . Fullfilled "_backward_squeeze(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_squeeze(ndarray)" args -> IO ()+_backward_squeeze_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_squeeze"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "depth_to_space(ndarray)" =+     '[ '("block_size", AttrReq Int), '("data", AttrOpt NDArrayHandle)]++depth_to_space ::+               forall args . Fullfilled "depth_to_space(ndarray)" args =>+                 ArgsHMap "depth_to_space(ndarray)" args -> IO [NDArrayHandle]+depth_to_space args+  = let scalarArgs+          = catMaybes+              [("block_size",) . showValue <$>+                 (args !? #block_size :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "depth_to_space"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++depth_to_space_upd ::+                   forall args . Fullfilled "depth_to_space(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "depth_to_space(ndarray)" args -> IO ()+depth_to_space_upd outputs args+  = let scalarArgs+          = catMaybes+              [("block_size",) . showValue <$>+                 (args !? #block_size :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "depth_to_space"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "space_to_depth(ndarray)" =+     '[ '("block_size", AttrReq Int), '("data", AttrOpt NDArrayHandle)]++space_to_depth ::+               forall args . Fullfilled "space_to_depth(ndarray)" args =>+                 ArgsHMap "space_to_depth(ndarray)" args -> IO [NDArrayHandle]+space_to_depth args+  = let scalarArgs+          = catMaybes+              [("block_size",) . showValue <$>+                 (args !? #block_size :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "space_to_depth"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++space_to_depth_upd ::+                   forall args . Fullfilled "space_to_depth(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "space_to_depth(ndarray)" args -> IO ()+space_to_depth_upd outputs args+  = let scalarArgs+          = catMaybes+              [("block_size",) . showValue <$>+                 (args !? #block_size :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "space_to_depth"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "dot(ndarray)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("forward_stype",+          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))),+        '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]++dot ::+    forall args . Fullfilled "dot(ndarray)" args =>+      ArgsHMap "dot(ndarray)" args -> IO [NDArrayHandle]+dot args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("forward_stype",) . showValue <$>+                 (args !? #forward_stype ::+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "dot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++dot_upd ::+        forall args . Fullfilled "dot(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "dot(ndarray)" args -> IO ()+dot_upd outputs args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("forward_stype",) . showValue <$>+                 (args !? #forward_stype ::+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "dot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_dot(ndarray)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("forward_stype",+          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"])))]++_backward_dot ::+              forall args . Fullfilled "_backward_dot(ndarray)" args =>+                ArgsHMap "_backward_dot(ndarray)" args -> IO [NDArrayHandle]+_backward_dot args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("forward_stype",) . showValue <$>+                 (args !? #forward_stype ::+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_dot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_dot_upd ::+                  forall args . Fullfilled "_backward_dot(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_dot(ndarray)" args -> IO ()+_backward_dot_upd outputs args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("forward_stype",) . showValue <$>+                 (args !? #forward_stype ::+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_dot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "batch_dot(ndarray)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("forward_stype",+          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))),+        '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]++batch_dot ::+          forall args . Fullfilled "batch_dot(ndarray)" args =>+            ArgsHMap "batch_dot(ndarray)" args -> IO [NDArrayHandle]+batch_dot args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("forward_stype",) . showValue <$>+                 (args !? #forward_stype ::+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "batch_dot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++batch_dot_upd ::+              forall args . Fullfilled "batch_dot(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "batch_dot(ndarray)" args -> IO ()+batch_dot_upd outputs args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("forward_stype",) . showValue <$>+                 (args !? #forward_stype ::+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "batch_dot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_batch_dot(ndarray)" = '[]++_backward_batch_dot ::+                    forall args . Fullfilled "_backward_batch_dot(ndarray)" args =>+                      ArgsHMap "_backward_batch_dot(ndarray)" args -> IO [NDArrayHandle]+_backward_batch_dot args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_batch_dot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_batch_dot_upd ::+                        forall args . Fullfilled "_backward_batch_dot(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_backward_batch_dot(ndarray)" args -> IO ()+_backward_batch_dot_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_batch_dot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "sin(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++sin ::+    forall args . Fullfilled "sin(ndarray)" args =>+      ArgsHMap "sin(ndarray)" args -> IO [NDArrayHandle]+sin args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++sin_upd ::+        forall args . Fullfilled "sin(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "sin(ndarray)" args -> IO ()+sin_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_sin(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_sin ::+              forall args . Fullfilled "_backward_sin(ndarray)" args =>+                ArgsHMap "_backward_sin(ndarray)" args -> IO [NDArrayHandle]+_backward_sin args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_sin_upd ::+                  forall args . Fullfilled "_backward_sin(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_sin(ndarray)" args -> IO ()+_backward_sin_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "cos(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++cos ::+    forall args . Fullfilled "cos(ndarray)" args =>+      ArgsHMap "cos(ndarray)" args -> IO [NDArrayHandle]+cos args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cos"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++cos_upd ::+        forall args . Fullfilled "cos(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "cos(ndarray)" args -> IO ()+cos_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cos"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_cos(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_cos ::+              forall args . Fullfilled "_backward_cos(ndarray)" args =>+                ArgsHMap "_backward_cos(ndarray)" args -> IO [NDArrayHandle]+_backward_cos args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cos"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_cos_upd ::+                  forall args . Fullfilled "_backward_cos(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_cos(ndarray)" args -> IO ()+_backward_cos_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cos"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "tan(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++tan ::+    forall args . Fullfilled "tan(ndarray)" args =>+      ArgsHMap "tan(ndarray)" args -> IO [NDArrayHandle]+tan args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tan"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++tan_upd ::+        forall args . Fullfilled "tan(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "tan(ndarray)" args -> IO ()+tan_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tan"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_tan(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_tan ::+              forall args . Fullfilled "_backward_tan(ndarray)" args =>+                ArgsHMap "_backward_tan(ndarray)" args -> IO [NDArrayHandle]+_backward_tan args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tan"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_tan_upd ::+                  forall args . Fullfilled "_backward_tan(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_tan(ndarray)" args -> IO ()+_backward_tan_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tan"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "arcsin(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++arcsin ::+       forall args . Fullfilled "arcsin(ndarray)" args =>+         ArgsHMap "arcsin(ndarray)" args -> IO [NDArrayHandle]+arcsin args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arcsin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++arcsin_upd ::+           forall args . Fullfilled "arcsin(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "arcsin(ndarray)" args -> IO ()+arcsin_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arcsin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_arcsin(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_arcsin ::+                 forall args . Fullfilled "_backward_arcsin(ndarray)" args =>+                   ArgsHMap "_backward_arcsin(ndarray)" args -> IO [NDArrayHandle]+_backward_arcsin args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arcsin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_arcsin_upd ::+                     forall args . Fullfilled "_backward_arcsin(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_backward_arcsin(ndarray)" args -> IO ()+_backward_arcsin_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arcsin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "arccos(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++arccos ::+       forall args . Fullfilled "arccos(ndarray)" args =>+         ArgsHMap "arccos(ndarray)" args -> IO [NDArrayHandle]+arccos args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arccos"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++arccos_upd ::+           forall args . Fullfilled "arccos(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "arccos(ndarray)" args -> IO ()+arccos_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arccos"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_arccos(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_arccos ::+                 forall args . Fullfilled "_backward_arccos(ndarray)" args =>+                   ArgsHMap "_backward_arccos(ndarray)" args -> IO [NDArrayHandle]+_backward_arccos args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arccos"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_arccos_upd ::+                     forall args . Fullfilled "_backward_arccos(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_backward_arccos(ndarray)" args -> IO ()+_backward_arccos_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arccos"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "arctan(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++arctan ::+       forall args . Fullfilled "arctan(ndarray)" args =>+         ArgsHMap "arctan(ndarray)" args -> IO [NDArrayHandle]+arctan args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arctan"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++arctan_upd ::+           forall args . Fullfilled "arctan(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "arctan(ndarray)" args -> IO ()+arctan_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arctan"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_arctan(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_arctan ::+                 forall args . Fullfilled "_backward_arctan(ndarray)" args =>+                   ArgsHMap "_backward_arctan(ndarray)" args -> IO [NDArrayHandle]+_backward_arctan args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arctan"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_arctan_upd ::+                     forall args . Fullfilled "_backward_arctan(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_backward_arctan(ndarray)" args -> IO ()+_backward_arctan_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arctan"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "degrees(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++degrees ::+        forall args . Fullfilled "degrees(ndarray)" args =>+          ArgsHMap "degrees(ndarray)" args -> IO [NDArrayHandle]+degrees args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "degrees"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++degrees_upd ::+            forall args . Fullfilled "degrees(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "degrees(ndarray)" args -> IO ()+degrees_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "degrees"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_degrees(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_degrees ::+                  forall args . Fullfilled "_backward_degrees(ndarray)" args =>+                    ArgsHMap "_backward_degrees(ndarray)" args -> IO [NDArrayHandle]+_backward_degrees args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_degrees"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_degrees_upd ::+                      forall args . Fullfilled "_backward_degrees(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_degrees(ndarray)" args -> IO ()+_backward_degrees_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_degrees"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "radians(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++radians ::+        forall args . Fullfilled "radians(ndarray)" args =>+          ArgsHMap "radians(ndarray)" args -> IO [NDArrayHandle]+radians args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "radians"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++radians_upd ::+            forall args . Fullfilled "radians(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "radians(ndarray)" args -> IO ()+radians_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "radians"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_radians(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_radians ::+                  forall args . Fullfilled "_backward_radians(ndarray)" args =>+                    ArgsHMap "_backward_radians(ndarray)" args -> IO [NDArrayHandle]+_backward_radians args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_radians"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_radians_upd ::+                      forall args . Fullfilled "_backward_radians(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_radians(ndarray)" args -> IO ()+_backward_radians_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_radians"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "sinh(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++sinh ::+     forall args . Fullfilled "sinh(ndarray)" args =>+       ArgsHMap "sinh(ndarray)" args -> IO [NDArrayHandle]+sinh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sinh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++sinh_upd ::+         forall args . Fullfilled "sinh(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "sinh(ndarray)" args -> IO ()+sinh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sinh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_sinh(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_sinh ::+               forall args . Fullfilled "_backward_sinh(ndarray)" args =>+                 ArgsHMap "_backward_sinh(ndarray)" args -> IO [NDArrayHandle]+_backward_sinh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sinh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_sinh_upd ::+                   forall args . Fullfilled "_backward_sinh(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_sinh(ndarray)" args -> IO ()+_backward_sinh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sinh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "cosh(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++cosh ::+     forall args . Fullfilled "cosh(ndarray)" args =>+       ArgsHMap "cosh(ndarray)" args -> IO [NDArrayHandle]+cosh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cosh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++cosh_upd ::+         forall args . Fullfilled "cosh(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "cosh(ndarray)" args -> IO ()+cosh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cosh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_cosh(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_cosh ::+               forall args . Fullfilled "_backward_cosh(ndarray)" args =>+                 ArgsHMap "_backward_cosh(ndarray)" args -> IO [NDArrayHandle]+_backward_cosh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cosh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_cosh_upd ::+                   forall args . Fullfilled "_backward_cosh(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_cosh(ndarray)" args -> IO ()+_backward_cosh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cosh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "tanh(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++tanh ::+     forall args . Fullfilled "tanh(ndarray)" args =>+       ArgsHMap "tanh(ndarray)" args -> IO [NDArrayHandle]+tanh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tanh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++tanh_upd ::+         forall args . Fullfilled "tanh(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "tanh(ndarray)" args -> IO ()+tanh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tanh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_tanh(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_tanh ::+               forall args . Fullfilled "_backward_tanh(ndarray)" args =>+                 ArgsHMap "_backward_tanh(ndarray)" args -> IO [NDArrayHandle]+_backward_tanh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tanh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_tanh_upd ::+                   forall args . Fullfilled "_backward_tanh(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_tanh(ndarray)" args -> IO ()+_backward_tanh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tanh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "arcsinh(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++arcsinh ::+        forall args . Fullfilled "arcsinh(ndarray)" args =>+          ArgsHMap "arcsinh(ndarray)" args -> IO [NDArrayHandle]+arcsinh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arcsinh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++arcsinh_upd ::+            forall args . Fullfilled "arcsinh(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "arcsinh(ndarray)" args -> IO ()+arcsinh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arcsinh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_arcsinh(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_arcsinh ::+                  forall args . Fullfilled "_backward_arcsinh(ndarray)" args =>+                    ArgsHMap "_backward_arcsinh(ndarray)" args -> IO [NDArrayHandle]+_backward_arcsinh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arcsinh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_arcsinh_upd ::+                      forall args . Fullfilled "_backward_arcsinh(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_arcsinh(ndarray)" args -> IO ()+_backward_arcsinh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arcsinh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "arccosh(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++arccosh ::+        forall args . Fullfilled "arccosh(ndarray)" args =>+          ArgsHMap "arccosh(ndarray)" args -> IO [NDArrayHandle]+arccosh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arccosh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++arccosh_upd ::+            forall args . Fullfilled "arccosh(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "arccosh(ndarray)" args -> IO ()+arccosh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arccosh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_arccosh(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_arccosh ::+                  forall args . Fullfilled "_backward_arccosh(ndarray)" args =>+                    ArgsHMap "_backward_arccosh(ndarray)" args -> IO [NDArrayHandle]+_backward_arccosh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arccosh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_arccosh_upd ::+                      forall args . Fullfilled "_backward_arccosh(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_arccosh(ndarray)" args -> IO ()+_backward_arccosh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arccosh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "arctanh(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++arctanh ::+        forall args . Fullfilled "arctanh(ndarray)" args =>+          ArgsHMap "arctanh(ndarray)" args -> IO [NDArrayHandle]+arctanh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arctanh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++arctanh_upd ::+            forall args . Fullfilled "arctanh(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "arctanh(ndarray)" args -> IO ()+arctanh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arctanh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_arctanh(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_arctanh ::+                  forall args . Fullfilled "_backward_arctanh(ndarray)" args =>+                    ArgsHMap "_backward_arctanh(ndarray)" args -> IO [NDArrayHandle]+_backward_arctanh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arctanh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_arctanh_upd ::+                      forall args . Fullfilled "_backward_arctanh(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_arctanh(ndarray)" args -> IO ()+_backward_arctanh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arctanh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_contrib_group_adagrad_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("epsilon", AttrOpt Float),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle),+        '("history", AttrOpt NDArrayHandle)]++_contrib_group_adagrad_update ::+                              forall args .+                                Fullfilled "_contrib_group_adagrad_update(ndarray)" args =>+                                ArgsHMap "_contrib_group_adagrad_update(ndarray)" args ->+                                  IO [NDArrayHandle]+_contrib_group_adagrad_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("history",) <$> (args !? #history :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_group_adagrad_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_group_adagrad_update_upd ::+                                  forall args .+                                    Fullfilled "_contrib_group_adagrad_update(ndarray)" args =>+                                    [NDArrayHandle] ->+                                      ArgsHMap "_contrib_group_adagrad_update(ndarray)" args ->+                                        IO ()+_contrib_group_adagrad_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("history",) <$> (args !? #history :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_group_adagrad_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_getnnz(ndarray)" =+     '[ '("axis", AttrOpt (Maybe Int)),+        '("data", AttrOpt NDArrayHandle)]++_contrib_getnnz ::+                forall args . Fullfilled "_contrib_getnnz(ndarray)" args =>+                  ArgsHMap "_contrib_getnnz(ndarray)" args -> IO [NDArrayHandle]+_contrib_getnnz args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_getnnz"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_getnnz_upd ::+                    forall args . Fullfilled "_contrib_getnnz(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_contrib_getnnz(ndarray)" args -> IO ()+_contrib_getnnz_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_getnnz"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_edge_id(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle), '("u", AttrOpt NDArrayHandle),+        '("v", AttrOpt NDArrayHandle)]++_contrib_edge_id ::+                 forall args . Fullfilled "_contrib_edge_id(ndarray)" args =>+                   ArgsHMap "_contrib_edge_id(ndarray)" args -> IO [NDArrayHandle]+_contrib_edge_id args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("u",) <$> (args !? #u :: Maybe NDArrayHandle),+               ("v",) <$> (args !? #v :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_edge_id"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_edge_id_upd ::+                     forall args . Fullfilled "_contrib_edge_id(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_contrib_edge_id(ndarray)" args -> IO ()+_contrib_edge_id_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("u",) <$> (args !? #u :: Maybe NDArrayHandle),+               ("v",) <$> (args !? #v :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_edge_id"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_dgl_adjacency(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_contrib_dgl_adjacency ::+                       forall args . Fullfilled "_contrib_dgl_adjacency(ndarray)" args =>+                         ArgsHMap "_contrib_dgl_adjacency(ndarray)" args ->+                           IO [NDArrayHandle]+_contrib_dgl_adjacency args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_dgl_adjacency"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_dgl_adjacency_upd ::+                           forall args . Fullfilled "_contrib_dgl_adjacency(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_contrib_dgl_adjacency(ndarray)" args -> IO ()+_contrib_dgl_adjacency_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_dgl_adjacency"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_quadratic(ndarray)" =+     '[ '("a", AttrOpt Float), '("b", AttrOpt Float),+        '("c", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_contrib_quadratic ::+                   forall args . Fullfilled "_contrib_quadratic(ndarray)" args =>+                     ArgsHMap "_contrib_quadratic(ndarray)" args -> IO [NDArrayHandle]+_contrib_quadratic args+  = let scalarArgs+          = catMaybes+              [("a",) . showValue <$> (args !? #a :: Maybe Float),+               ("b",) . showValue <$> (args !? #b :: Maybe Float),+               ("c",) . showValue <$> (args !? #c :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quadratic"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_quadratic_upd ::+                       forall args . Fullfilled "_contrib_quadratic(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_contrib_quadratic(ndarray)" args -> IO ()+_contrib_quadratic_upd outputs args+  = let scalarArgs+          = catMaybes+              [("a",) . showValue <$> (args !? #a :: Maybe Float),+               ("b",) . showValue <$> (args !? #b :: Maybe Float),+               ("c",) . showValue <$> (args !? #c :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quadratic"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_backward_quadratic(ndarray)"+     = '[]++_contrib_backward_quadratic ::+                            forall args .+                              Fullfilled "_contrib_backward_quadratic(ndarray)" args =>+                              ArgsHMap "_contrib_backward_quadratic(ndarray)" args ->+                                IO [NDArrayHandle]+_contrib_backward_quadratic args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_backward_quadratic"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_backward_quadratic_upd ::+                                forall args .+                                  Fullfilled "_contrib_backward_quadratic(ndarray)" args =>+                                  [NDArrayHandle] ->+                                    ArgsHMap "_contrib_backward_quadratic(ndarray)" args -> IO ()+_contrib_backward_quadratic_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_backward_quadratic"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_div_sqrt_dim(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_contrib_div_sqrt_dim ::+                      forall args . Fullfilled "_contrib_div_sqrt_dim(ndarray)" args =>+                        ArgsHMap "_contrib_div_sqrt_dim(ndarray)" args ->+                          IO [NDArrayHandle]+_contrib_div_sqrt_dim args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_div_sqrt_dim"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_div_sqrt_dim_upd ::+                          forall args . Fullfilled "_contrib_div_sqrt_dim(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_contrib_div_sqrt_dim(ndarray)" args -> IO ()+_contrib_div_sqrt_dim_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_div_sqrt_dim"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "khatri_rao(ndarray)" =+     '[ '("args", AttrOpt [NDArrayHandle])]++khatri_rao ::+           forall args . Fullfilled "khatri_rao(ndarray)" args =>+             ArgsHMap "khatri_rao(ndarray)" args -> IO [NDArrayHandle]+khatri_rao args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "khatri_rao"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        Nothing+         return listndarr++khatri_rao_upd ::+               forall args . Fullfilled "khatri_rao(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "khatri_rao(ndarray)" args -> IO ()+khatri_rao_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "khatri_rao"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_index_copy(ndarray)" =+     '[ '("old_tensor", AttrOpt NDArrayHandle),+        '("index_vector", AttrOpt NDArrayHandle),+        '("new_tensor", AttrOpt NDArrayHandle)]++_contrib_index_copy ::+                    forall args . Fullfilled "_contrib_index_copy(ndarray)" args =>+                      ArgsHMap "_contrib_index_copy(ndarray)" args -> IO [NDArrayHandle]+_contrib_index_copy args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("old_tensor",) <$> (args !? #old_tensor :: Maybe NDArrayHandle),+               ("index_vector",) <$>+                 (args !? #index_vector :: Maybe NDArrayHandle),+               ("new_tensor",) <$> (args !? #new_tensor :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_index_copy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_index_copy_upd ::+                        forall args . Fullfilled "_contrib_index_copy(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_contrib_index_copy(ndarray)" args -> IO ()+_contrib_index_copy_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("old_tensor",) <$> (args !? #old_tensor :: Maybe NDArrayHandle),+               ("index_vector",) <$>+                 (args !? #index_vector :: Maybe NDArrayHandle),+               ("new_tensor",) <$> (args !? #new_tensor :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_index_copy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_backward_index_copy(ndarray)"+     = '[]++_contrib_backward_index_copy ::+                             forall args .+                               Fullfilled "_contrib_backward_index_copy(ndarray)" args =>+                               ArgsHMap "_contrib_backward_index_copy(ndarray)" args ->+                                 IO [NDArrayHandle]+_contrib_backward_index_copy args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_backward_index_copy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_backward_index_copy_upd ::+                                 forall args .+                                   Fullfilled "_contrib_backward_index_copy(ndarray)" args =>+                                   [NDArrayHandle] ->+                                     ArgsHMap "_contrib_backward_index_copy(ndarray)" args -> IO ()+_contrib_backward_index_copy_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_backward_index_copy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_ROIAlign(ndarray)" =+     '[ '("pooled_size", AttrReq [Int]),+        '("spatial_scale", AttrReq Float), '("sample_ratio", AttrOpt Int),+        '("data", AttrOpt NDArrayHandle), '("rois", AttrOpt NDArrayHandle)]++_contrib_ROIAlign ::+                  forall args . Fullfilled "_contrib_ROIAlign(ndarray)" args =>+                    ArgsHMap "_contrib_ROIAlign(ndarray)" args -> IO [NDArrayHandle]+_contrib_ROIAlign args+  = let scalarArgs+          = catMaybes+              [("pooled_size",) . showValue <$>+                 (args !? #pooled_size :: Maybe [Int]),+               ("spatial_scale",) . showValue <$>+                 (args !? #spatial_scale :: Maybe Float),+               ("sample_ratio",) . showValue <$>+                 (args !? #sample_ratio :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_ROIAlign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_ROIAlign_upd ::+                      forall args . Fullfilled "_contrib_ROIAlign(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_contrib_ROIAlign(ndarray)" args -> IO ()+_contrib_ROIAlign_upd outputs args+  = let scalarArgs+          = catMaybes+              [("pooled_size",) . showValue <$>+                 (args !? #pooled_size :: Maybe [Int]),+               ("spatial_scale",) . showValue <$>+                 (args !? #spatial_scale :: Maybe Float),+               ("sample_ratio",) . showValue <$>+                 (args !? #sample_ratio :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_ROIAlign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_ROIAlign(ndarray)" = '[]++_backward_ROIAlign ::+                   forall args . Fullfilled "_backward_ROIAlign(ndarray)" args =>+                     ArgsHMap "_backward_ROIAlign(ndarray)" args -> IO [NDArrayHandle]+_backward_ROIAlign args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_ROIAlign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_ROIAlign_upd ::+                       forall args . Fullfilled "_backward_ROIAlign(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_backward_ROIAlign(ndarray)" args -> IO ()+_backward_ROIAlign_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_ROIAlign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_box_nms(ndarray)" =+     '[ '("overlap_thresh", AttrOpt Float),+        '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int),+        '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int),+        '("id_index", AttrOpt Int), '("force_suppress", AttrOpt Bool),+        '("in_format", AttrOpt (EnumType '["center", "corner"])),+        '("out_format", AttrOpt (EnumType '["center", "corner"])),+        '("data", AttrOpt NDArrayHandle)]++_contrib_box_nms ::+                 forall args . Fullfilled "_contrib_box_nms(ndarray)" args =>+                   ArgsHMap "_contrib_box_nms(ndarray)" args -> IO [NDArrayHandle]+_contrib_box_nms args+  = let scalarArgs+          = catMaybes+              [("overlap_thresh",) . showValue <$>+                 (args !? #overlap_thresh :: Maybe Float),+               ("valid_thresh",) . showValue <$>+                 (args !? #valid_thresh :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),+               ("coord_start",) . showValue <$>+                 (args !? #coord_start :: Maybe Int),+               ("score_index",) . showValue <$>+                 (args !? #score_index :: Maybe Int),+               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),+               ("force_suppress",) . showValue <$>+                 (args !? #force_suppress :: Maybe Bool),+               ("in_format",) . showValue <$>+                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),+               ("out_format",) . showValue <$>+                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_box_nms"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_box_nms_upd ::+                     forall args . Fullfilled "_contrib_box_nms(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_contrib_box_nms(ndarray)" args -> IO ()+_contrib_box_nms_upd outputs args+  = let scalarArgs+          = catMaybes+              [("overlap_thresh",) . showValue <$>+                 (args !? #overlap_thresh :: Maybe Float),+               ("valid_thresh",) . showValue <$>+                 (args !? #valid_thresh :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),+               ("coord_start",) . showValue <$>+                 (args !? #coord_start :: Maybe Int),+               ("score_index",) . showValue <$>+                 (args !? #score_index :: Maybe Int),+               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),+               ("force_suppress",) . showValue <$>+                 (args !? #force_suppress :: Maybe Bool),+               ("in_format",) . showValue <$>+                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),+               ("out_format",) . showValue <$>+                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_box_nms"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_contrib_box_nms(ndarray)" =+     '[ '("overlap_thresh", AttrOpt Float),+        '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int),+        '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int),+        '("id_index", AttrOpt Int), '("force_suppress", AttrOpt Bool),+        '("in_format", AttrOpt (EnumType '["center", "corner"])),+        '("out_format", AttrOpt (EnumType '["center", "corner"]))]++_backward_contrib_box_nms ::+                          forall args .+                            Fullfilled "_backward_contrib_box_nms(ndarray)" args =>+                            ArgsHMap "_backward_contrib_box_nms(ndarray)" args ->+                              IO [NDArrayHandle]+_backward_contrib_box_nms args+  = let scalarArgs+          = catMaybes+              [("overlap_thresh",) . showValue <$>+                 (args !? #overlap_thresh :: Maybe Float),+               ("valid_thresh",) . showValue <$>+                 (args !? #valid_thresh :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),+               ("coord_start",) . showValue <$>+                 (args !? #coord_start :: Maybe Int),+               ("score_index",) . showValue <$>+                 (args !? #score_index :: Maybe Int),+               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),+               ("force_suppress",) . showValue <$>+                 (args !? #force_suppress :: Maybe Bool),+               ("in_format",) . showValue <$>+                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),+               ("out_format",) . showValue <$>+                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_box_nms"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_contrib_box_nms_upd ::+                              forall args .+                                Fullfilled "_backward_contrib_box_nms(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_backward_contrib_box_nms(ndarray)" args -> IO ()+_backward_contrib_box_nms_upd outputs args+  = let scalarArgs+          = catMaybes+              [("overlap_thresh",) . showValue <$>+                 (args !? #overlap_thresh :: Maybe Float),+               ("valid_thresh",) . showValue <$>+                 (args !? #valid_thresh :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),+               ("coord_start",) . showValue <$>+                 (args !? #coord_start :: Maybe Int),+               ("score_index",) . showValue <$>+                 (args !? #score_index :: Maybe Int),+               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),+               ("force_suppress",) . showValue <$>+                 (args !? #force_suppress :: Maybe Bool),+               ("in_format",) . showValue <$>+                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),+               ("out_format",) . showValue <$>+                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_box_nms"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_box_iou(ndarray)" =+     '[ '("format", AttrOpt (EnumType '["center", "corner"])),+        '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]++_contrib_box_iou ::+                 forall args . Fullfilled "_contrib_box_iou(ndarray)" args =>+                   ArgsHMap "_contrib_box_iou(ndarray)" args -> IO [NDArrayHandle]+_contrib_box_iou args+  = let scalarArgs+          = catMaybes+              [("format",) . showValue <$>+                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_box_iou"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_box_iou_upd ::+                     forall args . Fullfilled "_contrib_box_iou(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_contrib_box_iou(ndarray)" args -> IO ()+_contrib_box_iou_upd outputs args+  = let scalarArgs+          = catMaybes+              [("format",) . showValue <$>+                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_box_iou"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_contrib_box_iou(ndarray)" =+     '[ '("format", AttrOpt (EnumType '["center", "corner"]))]++_backward_contrib_box_iou ::+                          forall args .+                            Fullfilled "_backward_contrib_box_iou(ndarray)" args =>+                            ArgsHMap "_backward_contrib_box_iou(ndarray)" args ->+                              IO [NDArrayHandle]+_backward_contrib_box_iou args+  = let scalarArgs+          = catMaybes+              [("format",) . showValue <$>+                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_box_iou"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_contrib_box_iou_upd ::+                              forall args .+                                Fullfilled "_backward_contrib_box_iou(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_backward_contrib_box_iou(ndarray)" args -> IO ()+_backward_contrib_box_iou_upd outputs args+  = let scalarArgs+          = catMaybes+              [("format",) . showValue <$>+                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_box_iou"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_bipartite_matching(ndarray)"+     =+     '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float),+        '("topk", AttrOpt Int), '("data", AttrOpt NDArrayHandle)]++_contrib_bipartite_matching ::+                            forall args .+                              Fullfilled "_contrib_bipartite_matching(ndarray)" args =>+                              ArgsHMap "_contrib_bipartite_matching(ndarray)" args ->+                                IO [NDArrayHandle]+_contrib_bipartite_matching args+  = let scalarArgs+          = catMaybes+              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_bipartite_matching"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_bipartite_matching_upd ::+                                forall args .+                                  Fullfilled "_contrib_bipartite_matching(ndarray)" args =>+                                  [NDArrayHandle] ->+                                    ArgsHMap "_contrib_bipartite_matching(ndarray)" args -> IO ()+_contrib_bipartite_matching_upd outputs args+  = let scalarArgs+          = catMaybes+              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_bipartite_matching"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward_contrib_bipartite_matching(ndarray)" =+     '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float),+        '("topk", AttrOpt Int)]++_backward_contrib_bipartite_matching ::+                                     forall args .+                                       Fullfilled "_backward_contrib_bipartite_matching(ndarray)"+                                         args =>+                                       ArgsHMap "_backward_contrib_bipartite_matching(ndarray)" args+                                         -> IO [NDArrayHandle]+_backward_contrib_bipartite_matching args+  = let scalarArgs+          = catMaybes+              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_bipartite_matching"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_contrib_bipartite_matching_upd ::+                                         forall args .+                                           Fullfilled+                                             "_backward_contrib_bipartite_matching(ndarray)" args =>+                                           [NDArrayHandle] ->+                                             ArgsHMap+                                               "_backward_contrib_bipartite_matching(ndarray)"+                                               args+                                               -> IO ()+_backward_contrib_bipartite_matching_upd outputs args+  = let scalarArgs+          = catMaybes+              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_bipartite_matching"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_BilinearResize2D(ndarray)" =+     '[ '("height", AttrReq Int), '("width", AttrReq Int),+        '("data", AttrOpt NDArrayHandle)]++_contrib_BilinearResize2D ::+                          forall args .+                            Fullfilled "_contrib_BilinearResize2D(ndarray)" args =>+                            ArgsHMap "_contrib_BilinearResize2D(ndarray)" args ->+                              IO [NDArrayHandle]+_contrib_BilinearResize2D args+  = let scalarArgs+          = catMaybes+              [("height",) . showValue <$> (args !? #height :: Maybe Int),+               ("width",) . showValue <$> (args !? #width :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_BilinearResize2D"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_BilinearResize2D_upd ::+                              forall args .+                                Fullfilled "_contrib_BilinearResize2D(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_contrib_BilinearResize2D(ndarray)" args -> IO ()+_contrib_BilinearResize2D_upd outputs args+  = let scalarArgs+          = catMaybes+              [("height",) . showValue <$> (args !? #height :: Maybe Int),+               ("width",) . showValue <$> (args !? #width :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_BilinearResize2D"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward_contrib_BilinearResize2D(ndarray)" = '[]++_backward_contrib_BilinearResize2D ::+                                   forall args .+                                     Fullfilled "_backward_contrib_BilinearResize2D(ndarray)"+                                       args =>+                                     ArgsHMap "_backward_contrib_BilinearResize2D(ndarray)" args ->+                                       IO [NDArrayHandle]+_backward_contrib_BilinearResize2D args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_BilinearResize2D"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_contrib_BilinearResize2D_upd ::+                                       forall args .+                                         Fullfilled "_backward_contrib_BilinearResize2D(ndarray)"+                                           args =>+                                         [NDArrayHandle] ->+                                           ArgsHMap "_backward_contrib_BilinearResize2D(ndarray)"+                                             args+                                             -> IO ()+_backward_contrib_BilinearResize2D_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_BilinearResize2D"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_boolean_mask(ndarray)" =+     '[ '("axis", AttrOpt Int), '("data", AttrOpt NDArrayHandle),+        '("index", AttrOpt NDArrayHandle)]++_contrib_boolean_mask ::+                      forall args . Fullfilled "_contrib_boolean_mask(ndarray)" args =>+                        ArgsHMap "_contrib_boolean_mask(ndarray)" args ->+                          IO [NDArrayHandle]+_contrib_boolean_mask args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("index",) <$> (args !? #index :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_boolean_mask"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_boolean_mask_upd ::+                          forall args . Fullfilled "_contrib_boolean_mask(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_contrib_boolean_mask(ndarray)" args -> IO ()+_contrib_boolean_mask_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("index",) <$> (args !? #index :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_boolean_mask"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward_contrib_boolean_mask(ndarray)" =+     '[ '("axis", AttrOpt Int)]++_backward_contrib_boolean_mask ::+                               forall args .+                                 Fullfilled "_backward_contrib_boolean_mask(ndarray)" args =>+                                 ArgsHMap "_backward_contrib_boolean_mask(ndarray)" args ->+                                   IO [NDArrayHandle]+_backward_contrib_boolean_mask args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_boolean_mask"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_contrib_boolean_mask_upd ::+                                   forall args .+                                     Fullfilled "_backward_contrib_boolean_mask(ndarray)" args =>+                                     [NDArrayHandle] ->+                                       ArgsHMap "_backward_contrib_boolean_mask(ndarray)" args ->+                                         IO ()+_backward_contrib_boolean_mask_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_boolean_mask"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_SyncBatchNorm(ndarray)" =+     '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float),+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),+        '("output_mean_var", AttrOpt Bool), '("ndev", AttrOpt Int),+        '("key", AttrOpt String), '("data", AttrOpt NDArrayHandle),+        '("gamma", AttrOpt NDArrayHandle),+        '("beta", AttrOpt NDArrayHandle),+        '("moving_mean", AttrOpt NDArrayHandle),+        '("moving_var", AttrOpt NDArrayHandle)]++_contrib_SyncBatchNorm ::+                       forall args . Fullfilled "_contrib_SyncBatchNorm(ndarray)" args =>+                         ArgsHMap "_contrib_SyncBatchNorm(ndarray)" args ->+                           IO [NDArrayHandle]+_contrib_SyncBatchNorm args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool),+               ("ndev",) . showValue <$> (args !? #ndev :: Maybe Int),+               ("key",) . showValue <$> (args !? #key :: Maybe String)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),+               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),+               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_SyncBatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_SyncBatchNorm_upd ::+                           forall args . Fullfilled "_contrib_SyncBatchNorm(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_contrib_SyncBatchNorm(ndarray)" args -> IO ()+_contrib_SyncBatchNorm_upd outputs args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool),+               ("ndev",) . showValue <$> (args !? #ndev :: Maybe Int),+               ("key",) . showValue <$> (args !? #key :: Maybe String)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),+               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),+               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_SyncBatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_contrib_AdaptiveAvgPooling2D(ndarray)" =+     '[ '("output_size", AttrOpt [Int]),+        '("data", AttrOpt NDArrayHandle)]++_contrib_AdaptiveAvgPooling2D ::+                              forall args .+                                Fullfilled "_contrib_AdaptiveAvgPooling2D(ndarray)" args =>+                                ArgsHMap "_contrib_AdaptiveAvgPooling2D(ndarray)" args ->+                                  IO [NDArrayHandle]+_contrib_AdaptiveAvgPooling2D args+  = let scalarArgs+          = catMaybes+              [("output_size",) . showValue <$>+                 (args !? #output_size :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_AdaptiveAvgPooling2D"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_AdaptiveAvgPooling2D_upd ::+                                  forall args .+                                    Fullfilled "_contrib_AdaptiveAvgPooling2D(ndarray)" args =>+                                    [NDArrayHandle] ->+                                      ArgsHMap "_contrib_AdaptiveAvgPooling2D(ndarray)" args ->+                                        IO ()+_contrib_AdaptiveAvgPooling2D_upd outputs args+  = let scalarArgs+          = catMaybes+              [("output_size",) . showValue <$>+                 (args !? #output_size :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_AdaptiveAvgPooling2D"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward_contrib_AdaptiveAvgPooling2D(ndarray)" =+     '[]++_backward_contrib_AdaptiveAvgPooling2D ::+                                       forall args .+                                         Fullfilled+                                           "_backward_contrib_AdaptiveAvgPooling2D(ndarray)" args =>+                                         ArgsHMap "_backward_contrib_AdaptiveAvgPooling2D(ndarray)"+                                           args+                                           -> IO [NDArrayHandle]+_backward_contrib_AdaptiveAvgPooling2D args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_AdaptiveAvgPooling2D"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_contrib_AdaptiveAvgPooling2D_upd ::+                                           forall args .+                                             Fullfilled+                                               "_backward_contrib_AdaptiveAvgPooling2D(ndarray)"+                                               args =>+                                             [NDArrayHandle] ->+                                               ArgsHMap+                                                 "_backward_contrib_AdaptiveAvgPooling2D(ndarray)"+                                                 args+                                                 -> IO ()+_backward_contrib_AdaptiveAvgPooling2D_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_AdaptiveAvgPooling2D"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_to_tensor(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_image_to_tensor ::+                 forall args . Fullfilled "_image_to_tensor(ndarray)" args =>+                   ArgsHMap "_image_to_tensor(ndarray)" args -> IO [NDArrayHandle]+_image_to_tensor args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_to_tensor"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_to_tensor_upd ::+                     forall args . Fullfilled "_image_to_tensor(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_image_to_tensor(ndarray)" args -> IO ()+_image_to_tensor_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_to_tensor"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_normalize(ndarray)" =+     '[ '("mean", AttrReq [Float]), '("std", AttrReq [Float]),+        '("data", AttrOpt NDArrayHandle)]++_image_normalize ::+                 forall args . Fullfilled "_image_normalize(ndarray)" args =>+                   ArgsHMap "_image_normalize(ndarray)" args -> IO [NDArrayHandle]+_image_normalize args+  = let scalarArgs+          = catMaybes+              [("mean",) . showValue <$> (args !? #mean :: Maybe [Float]),+               ("std",) . showValue <$> (args !? #std :: Maybe [Float])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_normalize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_normalize_upd ::+                     forall args . Fullfilled "_image_normalize(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_image_normalize(ndarray)" args -> IO ()+_image_normalize_upd outputs args+  = let scalarArgs+          = catMaybes+              [("mean",) . showValue <$> (args !? #mean :: Maybe [Float]),+               ("std",) . showValue <$> (args !? #std :: Maybe [Float])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_normalize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_flip_left_right(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_image_flip_left_right ::+                       forall args . Fullfilled "_image_flip_left_right(ndarray)" args =>+                         ArgsHMap "_image_flip_left_right(ndarray)" args ->+                           IO [NDArrayHandle]+_image_flip_left_right args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_flip_left_right"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_flip_left_right_upd ::+                           forall args . Fullfilled "_image_flip_left_right(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_image_flip_left_right(ndarray)" args -> IO ()+_image_flip_left_right_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_flip_left_right"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_image_random_flip_left_right(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_image_random_flip_left_right ::+                              forall args .+                                Fullfilled "_image_random_flip_left_right(ndarray)" args =>+                                ArgsHMap "_image_random_flip_left_right(ndarray)" args ->+                                  IO [NDArrayHandle]+_image_random_flip_left_right args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_flip_left_right"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_random_flip_left_right_upd ::+                                  forall args .+                                    Fullfilled "_image_random_flip_left_right(ndarray)" args =>+                                    [NDArrayHandle] ->+                                      ArgsHMap "_image_random_flip_left_right(ndarray)" args ->+                                        IO ()+_image_random_flip_left_right_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_flip_left_right"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_flip_top_bottom(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_image_flip_top_bottom ::+                       forall args . Fullfilled "_image_flip_top_bottom(ndarray)" args =>+                         ArgsHMap "_image_flip_top_bottom(ndarray)" args ->+                           IO [NDArrayHandle]+_image_flip_top_bottom args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_flip_top_bottom"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_flip_top_bottom_upd ::+                           forall args . Fullfilled "_image_flip_top_bottom(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_image_flip_top_bottom(ndarray)" args -> IO ()+_image_flip_top_bottom_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_flip_top_bottom"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_image_random_flip_top_bottom(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_image_random_flip_top_bottom ::+                              forall args .+                                Fullfilled "_image_random_flip_top_bottom(ndarray)" args =>+                                ArgsHMap "_image_random_flip_top_bottom(ndarray)" args ->+                                  IO [NDArrayHandle]+_image_random_flip_top_bottom args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_flip_top_bottom"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_random_flip_top_bottom_upd ::+                                  forall args .+                                    Fullfilled "_image_random_flip_top_bottom(ndarray)" args =>+                                    [NDArrayHandle] ->+                                      ArgsHMap "_image_random_flip_top_bottom(ndarray)" args ->+                                        IO ()+_image_random_flip_top_bottom_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_flip_top_bottom"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_random_brightness(ndarray)" =+     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),+        '("data", AttrOpt NDArrayHandle)]++_image_random_brightness ::+                         forall args .+                           Fullfilled "_image_random_brightness(ndarray)" args =>+                           ArgsHMap "_image_random_brightness(ndarray)" args ->+                             IO [NDArrayHandle]+_image_random_brightness args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_brightness"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_random_brightness_upd ::+                             forall args .+                               Fullfilled "_image_random_brightness(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_image_random_brightness(ndarray)" args -> IO ()+_image_random_brightness_upd outputs args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_brightness"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_random_contrast(ndarray)" =+     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),+        '("data", AttrOpt NDArrayHandle)]++_image_random_contrast ::+                       forall args . Fullfilled "_image_random_contrast(ndarray)" args =>+                         ArgsHMap "_image_random_contrast(ndarray)" args ->+                           IO [NDArrayHandle]+_image_random_contrast args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_contrast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_random_contrast_upd ::+                           forall args . Fullfilled "_image_random_contrast(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_image_random_contrast(ndarray)" args -> IO ()+_image_random_contrast_upd outputs args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_contrast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_random_saturation(ndarray)" =+     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),+        '("data", AttrOpt NDArrayHandle)]++_image_random_saturation ::+                         forall args .+                           Fullfilled "_image_random_saturation(ndarray)" args =>+                           ArgsHMap "_image_random_saturation(ndarray)" args ->+                             IO [NDArrayHandle]+_image_random_saturation args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_saturation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_random_saturation_upd ::+                             forall args .+                               Fullfilled "_image_random_saturation(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_image_random_saturation(ndarray)" args -> IO ()+_image_random_saturation_upd outputs args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_saturation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_random_hue(ndarray)" =+     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),+        '("data", AttrOpt NDArrayHandle)]++_image_random_hue ::+                  forall args . Fullfilled "_image_random_hue(ndarray)" args =>+                    ArgsHMap "_image_random_hue(ndarray)" args -> IO [NDArrayHandle]+_image_random_hue args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_hue"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_random_hue_upd ::+                      forall args . Fullfilled "_image_random_hue(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_image_random_hue(ndarray)" args -> IO ()+_image_random_hue_upd outputs args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_hue"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_random_color_jitter(ndarray)" =+     '[ '("brightness", AttrReq Float), '("contrast", AttrReq Float),+        '("saturation", AttrReq Float), '("hue", AttrReq Float),+        '("data", AttrOpt NDArrayHandle)]++_image_random_color_jitter ::+                           forall args .+                             Fullfilled "_image_random_color_jitter(ndarray)" args =>+                             ArgsHMap "_image_random_color_jitter(ndarray)" args ->+                               IO [NDArrayHandle]+_image_random_color_jitter args+  = let scalarArgs+          = catMaybes+              [("brightness",) . showValue <$>+                 (args !? #brightness :: Maybe Float),+               ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float),+               ("saturation",) . showValue <$>+                 (args !? #saturation :: Maybe Float),+               ("hue",) . showValue <$> (args !? #hue :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_color_jitter"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_random_color_jitter_upd ::+                               forall args .+                                 Fullfilled "_image_random_color_jitter(ndarray)" args =>+                                 [NDArrayHandle] ->+                                   ArgsHMap "_image_random_color_jitter(ndarray)" args -> IO ()+_image_random_color_jitter_upd outputs args+  = let scalarArgs+          = catMaybes+              [("brightness",) . showValue <$>+                 (args !? #brightness :: Maybe Float),+               ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float),+               ("saturation",) . showValue <$>+                 (args !? #saturation :: Maybe Float),+               ("hue",) . showValue <$> (args !? #hue :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_color_jitter"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_adjust_lighting(ndarray)" =+     '[ '("alpha", AttrReq [Float]), '("data", AttrOpt NDArrayHandle)]++_image_adjust_lighting ::+                       forall args . Fullfilled "_image_adjust_lighting(ndarray)" args =>+                         ArgsHMap "_image_adjust_lighting(ndarray)" args ->+                           IO [NDArrayHandle]+_image_adjust_lighting args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe [Float])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_adjust_lighting"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_adjust_lighting_upd ::+                           forall args . Fullfilled "_image_adjust_lighting(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_image_adjust_lighting(ndarray)" args -> IO ()+_image_adjust_lighting_upd outputs args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe [Float])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_adjust_lighting"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_random_lighting(ndarray)" =+     '[ '("alpha_std", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_image_random_lighting ::+                       forall args . Fullfilled "_image_random_lighting(ndarray)" args =>+                         ArgsHMap "_image_random_lighting(ndarray)" args ->+                           IO [NDArrayHandle]+_image_random_lighting args+  = let scalarArgs+          = catMaybes+              [("alpha_std",) . showValue <$>+                 (args !? #alpha_std :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_lighting"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_random_lighting_upd ::+                           forall args . Fullfilled "_image_random_lighting(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_image_random_lighting(ndarray)" args -> IO ()+_image_random_lighting_upd outputs args+  = let scalarArgs+          = catMaybes+              [("alpha_std",) . showValue <$>+                 (args !? #alpha_std :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_lighting"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "softmax(ndarray)" =+     '[ '("axis", AttrOpt Int),+        '("temperature", AttrOpt (Maybe Double)),+        '("data", AttrOpt NDArrayHandle)]++softmax ::+        forall args . Fullfilled "softmax(ndarray)" args =>+          ArgsHMap "softmax(ndarray)" args -> IO [NDArrayHandle]+softmax args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("temperature",) . showValue <$>+                 (args !? #temperature :: Maybe (Maybe Double))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++softmax_upd ::+            forall args . Fullfilled "softmax(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "softmax(ndarray)" args -> IO ()+softmax_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("temperature",) . showValue <$>+                 (args !? #temperature :: Maybe (Maybe Double))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_softmax(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_softmax ::+                  forall args . Fullfilled "_backward_softmax(ndarray)" args =>+                    ArgsHMap "_backward_softmax(ndarray)" args -> IO [NDArrayHandle]+_backward_softmax args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_softmax_upd ::+                      forall args . Fullfilled "_backward_softmax(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_softmax(ndarray)" args -> IO ()+_backward_softmax_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "softmin(ndarray)" =+     '[ '("axis", AttrOpt Int),+        '("temperature", AttrOpt (Maybe Double)),+        '("data", AttrOpt NDArrayHandle)]++softmin ::+        forall args . Fullfilled "softmin(ndarray)" args =>+          ArgsHMap "softmin(ndarray)" args -> IO [NDArrayHandle]+softmin args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("temperature",) . showValue <$>+                 (args !? #temperature :: Maybe (Maybe Double))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softmin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++softmin_upd ::+            forall args . Fullfilled "softmin(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "softmin(ndarray)" args -> IO ()+softmin_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("temperature",) . showValue <$>+                 (args !? #temperature :: Maybe (Maybe Double))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softmin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_softmin(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_softmin ::+                  forall args . Fullfilled "_backward_softmin(ndarray)" args =>+                    ArgsHMap "_backward_softmin(ndarray)" args -> IO [NDArrayHandle]+_backward_softmin args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_softmin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_softmin_upd ::+                      forall args . Fullfilled "_backward_softmin(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_softmin(ndarray)" args -> IO ()+_backward_softmin_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_softmin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "log_softmax(ndarray)" =+     '[ '("axis", AttrOpt Int),+        '("temperature", AttrOpt (Maybe Double)),+        '("data", AttrOpt NDArrayHandle)]++log_softmax ::+            forall args . Fullfilled "log_softmax(ndarray)" args =>+              ArgsHMap "log_softmax(ndarray)" args -> IO [NDArrayHandle]+log_softmax args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("temperature",) . showValue <$>+                 (args !? #temperature :: Maybe (Maybe Double))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log_softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++log_softmax_upd ::+                forall args . Fullfilled "log_softmax(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "log_softmax(ndarray)" args -> IO ()+log_softmax_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("temperature",) . showValue <$>+                 (args !? #temperature :: Maybe (Maybe Double))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log_softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_log_softmax(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_log_softmax ::+                      forall args . Fullfilled "_backward_log_softmax(ndarray)" args =>+                        ArgsHMap "_backward_log_softmax(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_log_softmax args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log_softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_log_softmax_upd ::+                          forall args . Fullfilled "_backward_log_softmax(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_log_softmax(ndarray)" args -> IO ()+_backward_log_softmax_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log_softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Pooling(ndarray)" =+     '[ '("kernel", AttrOpt [Int]),+        '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])),+        '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool),+        '("pooling_convention",+          AttrOpt (EnumType '["full", "same", "valid"])),+        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("p_value", AttrOpt (Maybe Int)),+        '("count_include_pad", AttrOpt (Maybe Bool)),+        '("data", AttrOpt NDArrayHandle)]++_Pooling ::+         forall args . Fullfilled "_Pooling(ndarray)" args =>+           ArgsHMap "_Pooling(ndarray)" args -> IO [NDArrayHandle]+_Pooling args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("pool_type",) . showValue <$>+                 (args !? #pool_type ::+                    Maybe (EnumType '["avg", "lp", "max", "sum"])),+               ("global_pool",) . showValue <$>+                 (args !? #global_pool :: Maybe Bool),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("pooling_convention",) . showValue <$>+                 (args !? #pooling_convention ::+                    Maybe (EnumType '["full", "same", "valid"])),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("p_value",) . showValue <$>+                 (args !? #p_value :: Maybe (Maybe Int)),+               ("count_include_pad",) . showValue <$>+                 (args !? #count_include_pad :: Maybe (Maybe Bool))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Pooling_upd ::+             forall args . Fullfilled "_Pooling(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "_Pooling(ndarray)" args -> IO ()+_Pooling_upd outputs args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("pool_type",) . showValue <$>+                 (args !? #pool_type ::+                    Maybe (EnumType '["avg", "lp", "max", "sum"])),+               ("global_pool",) . showValue <$>+                 (args !? #global_pool :: Maybe Bool),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("pooling_convention",) . showValue <$>+                 (args !? #pooling_convention ::+                    Maybe (EnumType '["full", "same", "valid"])),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("p_value",) . showValue <$>+                 (args !? #p_value :: Maybe (Maybe Int)),+               ("count_include_pad",) . showValue <$>+                 (args !? #count_include_pad :: Maybe (Maybe Bool))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Pooling(ndarray)" = '[]++_backward_Pooling ::+                  forall args . Fullfilled "_backward_Pooling(ndarray)" args =>+                    ArgsHMap "_backward_Pooling(ndarray)" args -> IO [NDArrayHandle]+_backward_Pooling args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Pooling_upd ::+                      forall args . Fullfilled "_backward_Pooling(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_Pooling(ndarray)" args -> IO ()+_backward_Pooling_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Deconvolution(ndarray)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("adj", AttrOpt [Int]), '("target_shape", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("cudnn_tune",+          AttrOpt+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+        '("cudnn_off", AttrOpt Bool),+        '("layout",+          AttrOpt+            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),+        '("data", AttrOpt NDArrayHandle),+        '("weight", AttrOpt NDArrayHandle),+        '("bias", AttrOpt NDArrayHandle)]++_Deconvolution ::+               forall args . Fullfilled "_Deconvolution(ndarray)" args =>+                 ArgsHMap "_Deconvolution(ndarray)" args -> IO [NDArrayHandle]+_Deconvolution args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Deconvolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Deconvolution_upd ::+                   forall args . Fullfilled "_Deconvolution(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_Deconvolution(ndarray)" args -> IO ()+_Deconvolution_upd outputs args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Deconvolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Deconvolution(ndarray)" =+     '[]++_backward_Deconvolution ::+                        forall args . Fullfilled "_backward_Deconvolution(ndarray)" args =>+                          ArgsHMap "_backward_Deconvolution(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_Deconvolution args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Deconvolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Deconvolution_upd ::+                            forall args . Fullfilled "_backward_Deconvolution(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_Deconvolution(ndarray)" args -> IO ()+_backward_Deconvolution_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Deconvolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Activation(ndarray)" =+     '[ '("act_type",+          AttrReq+            (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"])),+        '("data", AttrOpt NDArrayHandle)]++_Activation ::+            forall args . Fullfilled "_Activation(ndarray)" args =>+              ArgsHMap "_Activation(ndarray)" args -> IO [NDArrayHandle]+_Activation args+  = let scalarArgs+          = catMaybes+              [("act_type",) . showValue <$>+                 (args !? #act_type ::+                    Maybe+                      (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Activation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Activation_upd ::+                forall args . Fullfilled "_Activation(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_Activation(ndarray)" args -> IO ()+_Activation_upd outputs args+  = let scalarArgs+          = catMaybes+              [("act_type",) . showValue <$>+                 (args !? #act_type ::+                    Maybe+                      (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Activation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Activation(ndarray)" = '[]++_backward_Activation ::+                     forall args . Fullfilled "_backward_Activation(ndarray)" args =>+                       ArgsHMap "_backward_Activation(ndarray)" args -> IO [NDArrayHandle]+_backward_Activation args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Activation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Activation_upd ::+                         forall args . Fullfilled "_backward_Activation(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_Activation(ndarray)" args -> IO ()+_backward_Activation_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Activation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_UpSampling(ndarray)" =+     '[ '("scale", AttrReq Int), '("num_filter", AttrOpt Int),+        '("sample_type", AttrReq (EnumType '["bilinear", "nearest"])),+        '("multi_input_mode", AttrOpt (EnumType '["concat", "sum"])),+        '("num_args", AttrReq Int), '("workspace", AttrOpt Int),+        '("data", AttrOpt [NDArrayHandle])]++_UpSampling ::+            forall args . Fullfilled "_UpSampling(ndarray)" args =>+              ArgsHMap "_UpSampling(ndarray)" args -> IO [NDArrayHandle]+_UpSampling args+  = let scalarArgs+          = catMaybes+              [("scale",) . showValue <$> (args !? #scale :: Maybe Int),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("sample_type",) . showValue <$>+                 (args !? #sample_type ::+                    Maybe (EnumType '["bilinear", "nearest"])),+               ("multi_input_mode",) . showValue <$>+                 (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])),+               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "UpSampling"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        Nothing+         return listndarr++_UpSampling_upd ::+                forall args . Fullfilled "_UpSampling(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_UpSampling(ndarray)" args -> IO ()+_UpSampling_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scale",) . showValue <$> (args !? #scale :: Maybe Int),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("sample_type",) . showValue <$>+                 (args !? #sample_type ::+                    Maybe (EnumType '["bilinear", "nearest"])),+               ("multi_input_mode",) . showValue <$>+                 (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])),+               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "UpSampling"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        (Just outputs)+         return ()++type instance ParameterList "_backward_UpSampling(ndarray)" = '[]++_backward_UpSampling ::+                     forall args . Fullfilled "_backward_UpSampling(ndarray)" args =>+                       ArgsHMap "_backward_UpSampling(ndarray)" args -> IO [NDArrayHandle]+_backward_UpSampling args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_UpSampling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_UpSampling_upd ::+                         forall args . Fullfilled "_backward_UpSampling(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_UpSampling(ndarray)" args -> IO ()+_backward_UpSampling_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_UpSampling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_BatchNorm(ndarray)" =+     '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float),+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),+        '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int),+        '("cudnn_off", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),+        '("gamma", AttrOpt NDArrayHandle),+        '("beta", AttrOpt NDArrayHandle),+        '("moving_mean", AttrOpt NDArrayHandle),+        '("moving_var", AttrOpt NDArrayHandle)]++_BatchNorm ::+           forall args . Fullfilled "_BatchNorm(ndarray)" args =>+             ArgsHMap "_BatchNorm(ndarray)" args -> IO [NDArrayHandle]+_BatchNorm args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),+               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),+               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_BatchNorm_upd ::+               forall args . Fullfilled "_BatchNorm(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "_BatchNorm(ndarray)" args -> IO ()+_BatchNorm_upd outputs args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),+               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),+               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_BatchNorm(ndarray)" = '[]++_backward_BatchNorm ::+                    forall args . Fullfilled "_backward_BatchNorm(ndarray)" args =>+                      ArgsHMap "_backward_BatchNorm(ndarray)" args -> IO [NDArrayHandle]+_backward_BatchNorm args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_BatchNorm_upd ::+                        forall args . Fullfilled "_backward_BatchNorm(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_backward_BatchNorm(ndarray)" args -> IO ()+_backward_BatchNorm_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_CTCLoss(ndarray)" =+     '[ '("use_data_lengths", AttrOpt Bool),+        '("use_label_lengths", AttrOpt Bool),+        '("blank_label", AttrOpt (EnumType '["first", "last"])),+        '("data", AttrOpt NDArrayHandle),+        '("label", AttrOpt NDArrayHandle),+        '("data_lengths", AttrOpt NDArrayHandle),+        '("label_lengths", AttrOpt NDArrayHandle)]++_CTCLoss ::+         forall args . Fullfilled "_CTCLoss(ndarray)" args =>+           ArgsHMap "_CTCLoss(ndarray)" args -> IO [NDArrayHandle]+_CTCLoss args+  = let scalarArgs+          = catMaybes+              [("use_data_lengths",) . showValue <$>+                 (args !? #use_data_lengths :: Maybe Bool),+               ("use_label_lengths",) . showValue <$>+                 (args !? #use_label_lengths :: Maybe Bool),+               ("blank_label",) . showValue <$>+                 (args !? #blank_label :: Maybe (EnumType '["first", "last"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle),+               ("data_lengths",) <$>+                 (args !? #data_lengths :: Maybe NDArrayHandle),+               ("label_lengths",) <$>+                 (args !? #label_lengths :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "CTCLoss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_CTCLoss_upd ::+             forall args . Fullfilled "_CTCLoss(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "_CTCLoss(ndarray)" args -> IO ()+_CTCLoss_upd outputs args+  = let scalarArgs+          = catMaybes+              [("use_data_lengths",) . showValue <$>+                 (args !? #use_data_lengths :: Maybe Bool),+               ("use_label_lengths",) . showValue <$>+                 (args !? #use_label_lengths :: Maybe Bool),+               ("blank_label",) . showValue <$>+                 (args !? #blank_label :: Maybe (EnumType '["first", "last"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle),+               ("data_lengths",) <$>+                 (args !? #data_lengths :: Maybe NDArrayHandle),+               ("label_lengths",) <$>+                 (args !? #label_lengths :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "CTCLoss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_ctc_loss(ndarray)" = '[]++_backward_ctc_loss ::+                   forall args . Fullfilled "_backward_ctc_loss(ndarray)" args =>+                     ArgsHMap "_backward_ctc_loss(ndarray)" args -> IO [NDArrayHandle]+_backward_ctc_loss args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_ctc_loss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_ctc_loss_upd ::+                       forall args . Fullfilled "_backward_ctc_loss(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_backward_ctc_loss(ndarray)" args -> IO ()+_backward_ctc_loss_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_ctc_loss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_FullyConnected(ndarray)" =+     '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool),+        '("flatten", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),+        '("weight", AttrOpt NDArrayHandle),+        '("bias", AttrOpt NDArrayHandle)]++_FullyConnected ::+                forall args . Fullfilled "_FullyConnected(ndarray)" args =>+                  ArgsHMap "_FullyConnected(ndarray)" args -> IO [NDArrayHandle]+_FullyConnected args+  = let scalarArgs+          = catMaybes+              [("num_hidden",) . showValue <$>+                 (args !? #num_hidden :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "FullyConnected"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_FullyConnected_upd ::+                    forall args . Fullfilled "_FullyConnected(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_FullyConnected(ndarray)" args -> IO ()+_FullyConnected_upd outputs args+  = let scalarArgs+          = catMaybes+              [("num_hidden",) . showValue <$>+                 (args !? #num_hidden :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "FullyConnected"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_FullyConnected(ndarray)" =+     '[]++_backward_FullyConnected ::+                         forall args .+                           Fullfilled "_backward_FullyConnected(ndarray)" args =>+                           ArgsHMap "_backward_FullyConnected(ndarray)" args ->+                             IO [NDArrayHandle]+_backward_FullyConnected args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_FullyConnected"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_FullyConnected_upd ::+                             forall args .+                               Fullfilled "_backward_FullyConnected(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_backward_FullyConnected(ndarray)" args -> IO ()+_backward_FullyConnected_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_FullyConnected"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Convolution(ndarray)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("cudnn_tune",+          AttrOpt+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+        '("cudnn_off", AttrOpt Bool),+        '("layout",+          AttrOpt+            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),+        '("data", AttrOpt NDArrayHandle),+        '("weight", AttrOpt NDArrayHandle),+        '("bias", AttrOpt NDArrayHandle)]++_Convolution ::+             forall args . Fullfilled "_Convolution(ndarray)" args =>+               ArgsHMap "_Convolution(ndarray)" args -> IO [NDArrayHandle]+_Convolution args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Convolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Convolution_upd ::+                 forall args . Fullfilled "_Convolution(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_Convolution(ndarray)" args -> IO ()+_Convolution_upd outputs args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Convolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Convolution(ndarray)" = '[]++_backward_Convolution ::+                      forall args . Fullfilled "_backward_Convolution(ndarray)" args =>+                        ArgsHMap "_backward_Convolution(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_Convolution args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Convolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Convolution_upd ::+                          forall args . Fullfilled "_backward_Convolution(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_Convolution(ndarray)" args -> IO ()+_backward_Convolution_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Convolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_LayerNorm(ndarray)" =+     '[ '("axis", AttrOpt Int), '("eps", AttrOpt Float),+        '("output_mean_var", AttrOpt Bool),+        '("data", AttrOpt NDArrayHandle),+        '("gamma", AttrOpt NDArrayHandle),+        '("beta", AttrOpt NDArrayHandle)]++_LayerNorm ::+           forall args . Fullfilled "_LayerNorm(ndarray)" args =>+             ArgsHMap "_LayerNorm(ndarray)" args -> IO [NDArrayHandle]+_LayerNorm args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LayerNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_LayerNorm_upd ::+               forall args . Fullfilled "_LayerNorm(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "_LayerNorm(ndarray)" args -> IO ()+_LayerNorm_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LayerNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_LayerNorm(ndarray)" = '[]++_backward_LayerNorm ::+                    forall args . Fullfilled "_backward_LayerNorm(ndarray)" args =>+                      ArgsHMap "_backward_LayerNorm(ndarray)" args -> IO [NDArrayHandle]+_backward_LayerNorm args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LayerNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_LayerNorm_upd ::+                        forall args . Fullfilled "_backward_LayerNorm(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_backward_LayerNorm(ndarray)" args -> IO ()+_backward_LayerNorm_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LayerNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Concat(ndarray)" =+     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),+        '("data", AttrOpt [NDArrayHandle])]++_Concat ::+        forall args . Fullfilled "_Concat(ndarray)" args =>+          ArgsHMap "_Concat(ndarray)" args -> IO [NDArrayHandle]+_Concat args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "Concat"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        Nothing+         return listndarr++_Concat_upd ::+            forall args . Fullfilled "_Concat(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "_Concat(ndarray)" args -> IO ()+_Concat_upd outputs args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "Concat"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Concat(ndarray)" = '[]++_backward_Concat ::+                 forall args . Fullfilled "_backward_Concat(ndarray)" args =>+                   ArgsHMap "_backward_Concat(ndarray)" args -> IO [NDArrayHandle]+_backward_Concat args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Concat"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Concat_upd ::+                     forall args . Fullfilled "_backward_Concat(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_backward_Concat(ndarray)" args -> IO ()+_backward_Concat_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Concat"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_rnn_param_concat(ndarray)" =+     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),+        '("data", AttrOpt [NDArrayHandle])]++_rnn_param_concat ::+                  forall args . Fullfilled "_rnn_param_concat(ndarray)" args =>+                    ArgsHMap "_rnn_param_concat(ndarray)" args -> IO [NDArrayHandle]+_rnn_param_concat args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "_rnn_param_concat"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        Nothing+         return listndarr++_rnn_param_concat_upd ::+                      forall args . Fullfilled "_rnn_param_concat(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_rnn_param_concat(ndarray)" args -> IO ()+_rnn_param_concat_upd outputs args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "_rnn_param_concat"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        (Just outputs)+         return ()++type instance ParameterList "_SoftmaxActivation(ndarray)" =+     '[ '("mode", AttrOpt (EnumType '["channel", "instance"])),+        '("data", AttrOpt NDArrayHandle)]++_SoftmaxActivation ::+                   forall args . Fullfilled "_SoftmaxActivation(ndarray)" args =>+                     ArgsHMap "_SoftmaxActivation(ndarray)" args -> IO [NDArrayHandle]+_SoftmaxActivation args+  = let scalarArgs+          = catMaybes+              [("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["channel", "instance"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SoftmaxActivation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_SoftmaxActivation_upd ::+                       forall args . Fullfilled "_SoftmaxActivation(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_SoftmaxActivation(ndarray)" args -> IO ()+_SoftmaxActivation_upd outputs args+  = let scalarArgs+          = catMaybes+              [("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["channel", "instance"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SoftmaxActivation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SoftmaxActivation(ndarray)"+     = '[]++_backward_SoftmaxActivation ::+                            forall args .+                              Fullfilled "_backward_SoftmaxActivation(ndarray)" args =>+                              ArgsHMap "_backward_SoftmaxActivation(ndarray)" args ->+                                IO [NDArrayHandle]+_backward_SoftmaxActivation args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SoftmaxActivation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SoftmaxActivation_upd ::+                                forall args .+                                  Fullfilled "_backward_SoftmaxActivation(ndarray)" args =>+                                  [NDArrayHandle] ->+                                    ArgsHMap "_backward_SoftmaxActivation(ndarray)" args -> IO ()+_backward_SoftmaxActivation_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SoftmaxActivation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_LRN(ndarray)" =+     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),+        '("knorm", AttrOpt Float), '("nsize", AttrReq Int),+        '("data", AttrOpt NDArrayHandle)]++_LRN ::+     forall args . Fullfilled "_LRN(ndarray)" args =>+       ArgsHMap "_LRN(ndarray)" args -> IO [NDArrayHandle]+_LRN args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float),+               ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LRN"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_LRN_upd ::+         forall args . Fullfilled "_LRN(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "_LRN(ndarray)" args -> IO ()+_LRN_upd outputs args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float),+               ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LRN"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_LRN(ndarray)" = '[]++_backward_LRN ::+              forall args . Fullfilled "_backward_LRN(ndarray)" args =>+                ArgsHMap "_backward_LRN(ndarray)" args -> IO [NDArrayHandle]+_backward_LRN args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LRN"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_LRN_upd ::+                  forall args . Fullfilled "_backward_LRN(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_LRN(ndarray)" args -> IO ()+_backward_LRN_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LRN"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Dropout(ndarray)" =+     '[ '("p", AttrOpt Float),+        '("mode", AttrOpt (EnumType '["always", "training"])),+        '("axes", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]++_Dropout ::+         forall args . Fullfilled "_Dropout(ndarray)" args =>+           ArgsHMap "_Dropout(ndarray)" args -> IO [NDArrayHandle]+_Dropout args+  = let scalarArgs+          = catMaybes+              [("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["always", "training"])),+               ("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Dropout"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Dropout_upd ::+             forall args . Fullfilled "_Dropout(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "_Dropout(ndarray)" args -> IO ()+_Dropout_upd outputs args+  = let scalarArgs+          = catMaybes+              [("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["always", "training"])),+               ("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Dropout"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Dropout(ndarray)" = '[]++_backward_Dropout ::+                  forall args . Fullfilled "_backward_Dropout(ndarray)" args =>+                    ArgsHMap "_backward_Dropout(ndarray)" args -> IO [NDArrayHandle]+_backward_Dropout args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Dropout"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Dropout_upd ::+                      forall args . Fullfilled "_backward_Dropout(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_Dropout(ndarray)" args -> IO ()+_backward_Dropout_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Dropout"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_dequantize(ndarray)" =+     '[ '("out_type", AttrOpt (EnumType '["float32"])),+        '("data", AttrOpt NDArrayHandle),+        '("min_range", AttrOpt NDArrayHandle),+        '("max_range", AttrOpt NDArrayHandle)]++_contrib_dequantize ::+                    forall args . Fullfilled "_contrib_dequantize(ndarray)" args =>+                      ArgsHMap "_contrib_dequantize(ndarray)" args -> IO [NDArrayHandle]+_contrib_dequantize args+  = let scalarArgs+          = catMaybes+              [("out_type",) . showValue <$>+                 (args !? #out_type :: Maybe (EnumType '["float32"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),+               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_dequantize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_dequantize_upd ::+                        forall args . Fullfilled "_contrib_dequantize(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_contrib_dequantize(ndarray)" args -> IO ()+_contrib_dequantize_upd outputs args+  = let scalarArgs+          = catMaybes+              [("out_type",) . showValue <$>+                 (args !? #out_type :: Maybe (EnumType '["float32"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),+               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_dequantize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_quantized_flatten(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle),+        '("min_data", AttrOpt NDArrayHandle),+        '("max_data", AttrOpt NDArrayHandle)]++_contrib_quantized_flatten ::+                           forall args .+                             Fullfilled "_contrib_quantized_flatten(ndarray)" args =>+                             ArgsHMap "_contrib_quantized_flatten(ndarray)" args ->+                               IO [NDArrayHandle]+_contrib_quantized_flatten args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_flatten"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_quantized_flatten_upd ::+                               forall args .+                                 Fullfilled "_contrib_quantized_flatten(ndarray)" args =>+                                 [NDArrayHandle] ->+                                   ArgsHMap "_contrib_quantized_flatten(ndarray)" args -> IO ()+_contrib_quantized_flatten_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_flatten"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_quantized_conv(ndarray)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("cudnn_tune",+          AttrOpt+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+        '("cudnn_off", AttrOpt Bool),+        '("layout",+          AttrOpt+            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),+        '("data", AttrOpt NDArrayHandle),+        '("weight", AttrOpt NDArrayHandle),+        '("bias", AttrOpt NDArrayHandle),+        '("min_data", AttrOpt NDArrayHandle),+        '("max_data", AttrOpt NDArrayHandle),+        '("min_weight", AttrOpt NDArrayHandle),+        '("max_weight", AttrOpt NDArrayHandle),+        '("min_bias", AttrOpt NDArrayHandle),+        '("max_bias", AttrOpt NDArrayHandle)]++_contrib_quantized_conv ::+                        forall args . Fullfilled "_contrib_quantized_conv(ndarray)" args =>+                          ArgsHMap "_contrib_quantized_conv(ndarray)" args ->+                            IO [NDArrayHandle]+_contrib_quantized_conv args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle),+               ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle),+               ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle),+               ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle),+               ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_conv"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_quantized_conv_upd ::+                            forall args . Fullfilled "_contrib_quantized_conv(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_contrib_quantized_conv(ndarray)" args -> IO ()+_contrib_quantized_conv_upd outputs args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle),+               ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle),+               ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle),+               ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle),+               ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_conv"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_contrib_quantized_fully_connected(ndarray)" =+     '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool),+        '("flatten", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),+        '("weight", AttrOpt NDArrayHandle),+        '("bias", AttrOpt NDArrayHandle),+        '("min_data", AttrOpt NDArrayHandle),+        '("max_data", AttrOpt NDArrayHandle),+        '("min_weight", AttrOpt NDArrayHandle),+        '("max_weight", AttrOpt NDArrayHandle),+        '("min_bias", AttrOpt NDArrayHandle),+        '("max_bias", AttrOpt NDArrayHandle)]++_contrib_quantized_fully_connected ::+                                   forall args .+                                     Fullfilled "_contrib_quantized_fully_connected(ndarray)"+                                       args =>+                                     ArgsHMap "_contrib_quantized_fully_connected(ndarray)" args ->+                                       IO [NDArrayHandle]+_contrib_quantized_fully_connected args+  = let scalarArgs+          = catMaybes+              [("num_hidden",) . showValue <$>+                 (args !? #num_hidden :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle),+               ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle),+               ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle),+               ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle),+               ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_fully_connected"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_quantized_fully_connected_upd ::+                                       forall args .+                                         Fullfilled "_contrib_quantized_fully_connected(ndarray)"+                                           args =>+                                         [NDArrayHandle] ->+                                           ArgsHMap "_contrib_quantized_fully_connected(ndarray)"+                                             args+                                             -> IO ()+_contrib_quantized_fully_connected_upd outputs args+  = let scalarArgs+          = catMaybes+              [("num_hidden",) . showValue <$>+                 (args !? #num_hidden :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle),+               ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle),+               ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle),+               ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle),+               ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_fully_connected"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_quantized_pooling(ndarray)" =+     '[ '("kernel", AttrOpt [Int]),+        '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])),+        '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool),+        '("pooling_convention",+          AttrOpt (EnumType '["full", "same", "valid"])),+        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("p_value", AttrOpt (Maybe Int)),+        '("count_include_pad", AttrOpt (Maybe Bool)),+        '("data", AttrOpt NDArrayHandle),+        '("min_data", AttrOpt NDArrayHandle),+        '("max_data", AttrOpt NDArrayHandle)]++_contrib_quantized_pooling ::+                           forall args .+                             Fullfilled "_contrib_quantized_pooling(ndarray)" args =>+                             ArgsHMap "_contrib_quantized_pooling(ndarray)" args ->+                               IO [NDArrayHandle]+_contrib_quantized_pooling args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("pool_type",) . showValue <$>+                 (args !? #pool_type ::+                    Maybe (EnumType '["avg", "lp", "max", "sum"])),+               ("global_pool",) . showValue <$>+                 (args !? #global_pool :: Maybe Bool),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("pooling_convention",) . showValue <$>+                 (args !? #pooling_convention ::+                    Maybe (EnumType '["full", "same", "valid"])),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("p_value",) . showValue <$>+                 (args !? #p_value :: Maybe (Maybe Int)),+               ("count_include_pad",) . showValue <$>+                 (args !? #count_include_pad :: Maybe (Maybe Bool))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_pooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_quantized_pooling_upd ::+                               forall args .+                                 Fullfilled "_contrib_quantized_pooling(ndarray)" args =>+                                 [NDArrayHandle] ->+                                   ArgsHMap "_contrib_quantized_pooling(ndarray)" args -> IO ()+_contrib_quantized_pooling_upd outputs args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("pool_type",) . showValue <$>+                 (args !? #pool_type ::+                    Maybe (EnumType '["avg", "lp", "max", "sum"])),+               ("global_pool",) . showValue <$>+                 (args !? #global_pool :: Maybe Bool),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("pooling_convention",) . showValue <$>+                 (args !? #pooling_convention ::+                    Maybe (EnumType '["full", "same", "valid"])),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("p_value",) . showValue <$>+                 (args !? #p_value :: Maybe (Maybe Int)),+               ("count_include_pad",) . showValue <$>+                 (args !? #count_include_pad :: Maybe (Maybe Bool))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_pooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_quantized_concat(ndarray)" =+     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),+        '("data", AttrOpt [NDArrayHandle])]++_contrib_quantized_concat ::+                          forall args .+                            Fullfilled "_contrib_quantized_concat(ndarray)" args =>+                            ArgsHMap "_contrib_quantized_concat(ndarray)" args ->+                              IO [NDArrayHandle]+_contrib_quantized_concat args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "_contrib_quantized_concat"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        Nothing+         return listndarr++_contrib_quantized_concat_upd ::+                              forall args .+                                Fullfilled "_contrib_quantized_concat(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_contrib_quantized_concat(ndarray)" args -> IO ()+_contrib_quantized_concat_upd outputs args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "_contrib_quantized_concat"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_requantize(ndarray)" =+     '[ '("min_calib_range", AttrOpt (Maybe Float)),+        '("max_calib_range", AttrOpt (Maybe Float)),+        '("data", AttrOpt NDArrayHandle),+        '("min_range", AttrOpt NDArrayHandle),+        '("max_range", AttrOpt NDArrayHandle)]++_contrib_requantize ::+                    forall args . Fullfilled "_contrib_requantize(ndarray)" args =>+                      ArgsHMap "_contrib_requantize(ndarray)" args -> IO [NDArrayHandle]+_contrib_requantize args+  = let scalarArgs+          = catMaybes+              [("min_calib_range",) . showValue <$>+                 (args !? #min_calib_range :: Maybe (Maybe Float)),+               ("max_calib_range",) . showValue <$>+                 (args !? #max_calib_range :: Maybe (Maybe Float))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),+               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_requantize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_requantize_upd ::+                        forall args . Fullfilled "_contrib_requantize(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_contrib_requantize(ndarray)" args -> IO ()+_contrib_requantize_upd outputs args+  = let scalarArgs+          = catMaybes+              [("min_calib_range",) . showValue <$>+                 (args !? #min_calib_range :: Maybe (Maybe Float)),+               ("max_calib_range",) . showValue <$>+                 (args !? #max_calib_range :: Maybe (Maybe Float))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),+               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_requantize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_quantize(ndarray)" =+     '[ '("out_type", AttrOpt (EnumType '["int8", "uint8"])),+        '("data", AttrOpt NDArrayHandle),+        '("min_range", AttrOpt NDArrayHandle),+        '("max_range", AttrOpt NDArrayHandle)]++_contrib_quantize ::+                  forall args . Fullfilled "_contrib_quantize(ndarray)" args =>+                    ArgsHMap "_contrib_quantize(ndarray)" args -> IO [NDArrayHandle]+_contrib_quantize args+  = let scalarArgs+          = catMaybes+              [("out_type",) . showValue <$>+                 (args !? #out_type :: Maybe (EnumType '["int8", "uint8"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),+               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_quantize_upd ::+                      forall args . Fullfilled "_contrib_quantize(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_contrib_quantize(ndarray)" args -> IO ()+_contrib_quantize_upd outputs args+  = let scalarArgs+          = catMaybes+              [("out_type",) . showValue <$>+                 (args !? #out_type :: Maybe (EnumType '["int8", "uint8"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),+               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_cvimdecode(ndarray)" =+     '[ '("flag", AttrOpt Int), '("to_rgb", AttrOpt Bool),+        '("buf", AttrOpt NDArrayHandle)]++_cvimdecode ::+            forall args . Fullfilled "_cvimdecode(ndarray)" args =>+              ArgsHMap "_cvimdecode(ndarray)" args -> IO [NDArrayHandle]+_cvimdecode args+  = let scalarArgs+          = catMaybes+              [("flag",) . showValue <$> (args !? #flag :: Maybe Int),+               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]+        tensorArgs+          = catMaybes [("buf",) <$> (args !? #buf :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_cvimdecode"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_cvimdecode_upd ::+                forall args . Fullfilled "_cvimdecode(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_cvimdecode(ndarray)" args -> IO ()+_cvimdecode_upd outputs args+  = let scalarArgs+          = catMaybes+              [("flag",) . showValue <$> (args !? #flag :: Maybe Int),+               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]+        tensorArgs+          = catMaybes [("buf",) <$> (args !? #buf :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_cvimdecode"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_cvimread(ndarray)" =+     '[ '("filename", AttrReq String), '("flag", AttrOpt Int),+        '("to_rgb", AttrOpt Bool)]++_cvimread ::+          forall args . Fullfilled "_cvimread(ndarray)" args =>+            ArgsHMap "_cvimread(ndarray)" args -> IO [NDArrayHandle]+_cvimread args+  = let scalarArgs+          = catMaybes+              [("filename",) . showValue <$> (args !? #filename :: Maybe String),+               ("flag",) . showValue <$> (args !? #flag :: Maybe Int),+               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_cvimread"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_cvimread_upd ::+              forall args . Fullfilled "_cvimread(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "_cvimread(ndarray)" args -> IO ()+_cvimread_upd outputs args+  = let scalarArgs+          = catMaybes+              [("filename",) . showValue <$> (args !? #filename :: Maybe String),+               ("flag",) . showValue <$> (args !? #flag :: Maybe Int),+               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_cvimread"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_cvimresize(ndarray)" =+     '[ '("w", AttrReq Int), '("h", AttrReq Int),+        '("interp", AttrOpt Int), '("src", AttrOpt NDArrayHandle)]++_cvimresize ::+            forall args . Fullfilled "_cvimresize(ndarray)" args =>+              ArgsHMap "_cvimresize(ndarray)" args -> IO [NDArrayHandle]+_cvimresize args+  = let scalarArgs+          = catMaybes+              [("w",) . showValue <$> (args !? #w :: Maybe Int),+               ("h",) . showValue <$> (args !? #h :: Maybe Int),+               ("interp",) . showValue <$> (args !? #interp :: Maybe Int)]+        tensorArgs+          = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_cvimresize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_cvimresize_upd ::+                forall args . Fullfilled "_cvimresize(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_cvimresize(ndarray)" args -> IO ()+_cvimresize_upd outputs args+  = let scalarArgs+          = catMaybes+              [("w",) . showValue <$> (args !? #w :: Maybe Int),+               ("h",) . showValue <$> (args !? #h :: Maybe Int),+               ("interp",) . showValue <$> (args !? #interp :: Maybe Int)]+        tensorArgs+          = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_cvimresize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_cvcopyMakeBorder(ndarray)" =+     '[ '("top", AttrReq Int), '("bot", AttrReq Int),+        '("left", AttrReq Int), '("right", AttrReq Int),+        '("type", AttrOpt Int), '("value", AttrOpt Double),+        '("values", AttrOpt [Double]), '("src", AttrOpt NDArrayHandle)]++_cvcopyMakeBorder ::+                  forall args . Fullfilled "_cvcopyMakeBorder(ndarray)" args =>+                    ArgsHMap "_cvcopyMakeBorder(ndarray)" args -> IO [NDArrayHandle]+_cvcopyMakeBorder args+  = let scalarArgs+          = catMaybes+              [("top",) . showValue <$> (args !? #top :: Maybe Int),+               ("bot",) . showValue <$> (args !? #bot :: Maybe Int),+               ("left",) . showValue <$> (args !? #left :: Maybe Int),+               ("right",) . showValue <$> (args !? #right :: Maybe Int),+               ("type",) . showValue <$> (args !? #type :: Maybe Int),+               ("value",) . showValue <$> (args !? #value :: Maybe Double),+               ("values",) . showValue <$> (args !? #values :: Maybe [Double])]+        tensorArgs+          = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_cvcopyMakeBorder"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_cvcopyMakeBorder_upd ::+                      forall args . Fullfilled "_cvcopyMakeBorder(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_cvcopyMakeBorder(ndarray)" args -> IO ()+_cvcopyMakeBorder_upd outputs args+  = let scalarArgs+          = catMaybes+              [("top",) . showValue <$> (args !? #top :: Maybe Int),+               ("bot",) . showValue <$> (args !? #bot :: Maybe Int),+               ("left",) . showValue <$> (args !? #left :: Maybe Int),+               ("right",) . showValue <$> (args !? #right :: Maybe Int),+               ("type",) . showValue <$> (args !? #type :: Maybe Int),+               ("value",) . showValue <$> (args !? #value :: Maybe Double),+               ("values",) . showValue <$> (args !? #values :: Maybe [Double])]+        tensorArgs+          = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_cvcopyMakeBorder"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_NoGradient(ndarray)" = '[]++_NoGradient ::+            forall args . Fullfilled "_NoGradient(ndarray)" args =>+              ArgsHMap "_NoGradient(ndarray)" args -> IO [NDArrayHandle]+_NoGradient args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_NoGradient"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_NoGradient_upd ::+                forall args . Fullfilled "_NoGradient(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_NoGradient(ndarray)" args -> IO ()+_NoGradient_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_NoGradient"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_CachedOp(ndarray)" =+     '[ '("data", AttrOpt [NDArrayHandle])]++_CachedOp ::+          forall args . Fullfilled "_CachedOp(ndarray)" args =>+            ArgsHMap "_CachedOp(ndarray)" args -> IO [NDArrayHandle]+_CachedOp args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "_CachedOp"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_CachedOp_upd ::+              forall args . Fullfilled "_CachedOp(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "_CachedOp(ndarray)" args -> IO ()+_CachedOp_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "_CachedOp"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_CachedOp(ndarray)" = '[]++_backward_CachedOp ::+                   forall args . Fullfilled "_backward_CachedOp(ndarray)" args =>+                     ArgsHMap "_backward_CachedOp(ndarray)" args -> IO [NDArrayHandle]+_backward_CachedOp args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_CachedOp"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_CachedOp_upd ::+                       forall args . Fullfilled "_backward_CachedOp(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_backward_CachedOp(ndarray)" args -> IO ()+_backward_CachedOp_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_CachedOp"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_copyto(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_copyto ::+        forall args . Fullfilled "_copyto(ndarray)" args =>+          ArgsHMap "_copyto(ndarray)" args -> IO [NDArrayHandle]+_copyto args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_copyto"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_copyto_upd ::+            forall args . Fullfilled "_copyto(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "_copyto(ndarray)" args -> IO ()+_copyto_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_copyto"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "softmax_cross_entropy(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle),+        '("label", AttrOpt NDArrayHandle)]++softmax_cross_entropy ::+                      forall args . Fullfilled "softmax_cross_entropy(ndarray)" args =>+                        ArgsHMap "softmax_cross_entropy(ndarray)" args ->+                          IO [NDArrayHandle]+softmax_cross_entropy args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softmax_cross_entropy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++softmax_cross_entropy_upd ::+                          forall args . Fullfilled "softmax_cross_entropy(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "softmax_cross_entropy(ndarray)" args -> IO ()+softmax_cross_entropy_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softmax_cross_entropy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward_softmax_cross_entropy(ndarray)" = '[]++_backward_softmax_cross_entropy ::+                                forall args .+                                  Fullfilled "_backward_softmax_cross_entropy(ndarray)" args =>+                                  ArgsHMap "_backward_softmax_cross_entropy(ndarray)" args ->+                                    IO [NDArrayHandle]+_backward_softmax_cross_entropy args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_softmax_cross_entropy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_softmax_cross_entropy_upd ::+                                    forall args .+                                      Fullfilled "_backward_softmax_cross_entropy(ndarray)" args =>+                                      [NDArrayHandle] ->+                                        ArgsHMap "_backward_softmax_cross_entropy(ndarray)" args ->+                                          IO ()+_backward_softmax_cross_entropy_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_softmax_cross_entropy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Pad(ndarray)" =+     '[ '("mode", AttrReq (EnumType '["constant", "edge", "reflect"])),+        '("pad_width", AttrReq [Int]), '("constant_value", AttrOpt Double),+        '("data", AttrOpt NDArrayHandle)]++_Pad ::+     forall args . Fullfilled "_Pad(ndarray)" args =>+       ArgsHMap "_Pad(ndarray)" args -> IO [NDArrayHandle]+_Pad args+  = let scalarArgs+          = catMaybes+              [("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["constant", "edge", "reflect"])),+               ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]),+               ("constant_value",) . showValue <$>+                 (args !? #constant_value :: Maybe Double)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pad"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Pad_upd ::+         forall args . Fullfilled "_Pad(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "_Pad(ndarray)" args -> IO ()+_Pad_upd outputs args+  = let scalarArgs+          = catMaybes+              [("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["constant", "edge", "reflect"])),+               ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]),+               ("constant_value",) . showValue <$>+                 (args !? #constant_value :: Maybe Double)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pad"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_foreach(ndarray)" = '[]++_backward_foreach ::+                  forall args . Fullfilled "_backward_foreach(ndarray)" args =>+                    ArgsHMap "_backward_foreach(ndarray)" args -> IO [NDArrayHandle]+_backward_foreach args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_foreach"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_foreach_upd ::+                      forall args . Fullfilled "_backward_foreach(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_foreach(ndarray)" args -> IO ()+_backward_foreach_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_foreach"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_while_loop(ndarray)" = '[]++_backward_while_loop ::+                     forall args . Fullfilled "_backward_while_loop(ndarray)" args =>+                       ArgsHMap "_backward_while_loop(ndarray)" args -> IO [NDArrayHandle]+_backward_while_loop args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_while_loop"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_while_loop_upd ::+                         forall args . Fullfilled "_backward_while_loop(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_while_loop(ndarray)" args -> IO ()+_backward_while_loop_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_while_loop"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_cond(ndarray)" = '[]++_backward_cond ::+               forall args . Fullfilled "_backward_cond(ndarray)" args =>+                 ArgsHMap "_backward_cond(ndarray)" args -> IO [NDArrayHandle]+_backward_cond args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cond"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_cond_upd ::+                   forall args . Fullfilled "_backward_cond(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_cond(ndarray)" args -> IO ()+_backward_cond_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cond"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_LeakyReLU(ndarray)" =+     '[ '("act_type",+          AttrOpt (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])),+        '("slope", AttrOpt Float), '("lower_bound", AttrOpt Float),+        '("upper_bound", AttrOpt Float), '("data", AttrOpt NDArrayHandle),+        '("gamma", AttrOpt NDArrayHandle)]++_LeakyReLU ::+           forall args . Fullfilled "_LeakyReLU(ndarray)" args =>+             ArgsHMap "_LeakyReLU(ndarray)" args -> IO [NDArrayHandle]+_LeakyReLU args+  = let scalarArgs+          = catMaybes+              [("act_type",) . showValue <$>+                 (args !? #act_type ::+                    Maybe (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])),+               ("slope",) . showValue <$> (args !? #slope :: Maybe Float),+               ("lower_bound",) . showValue <$>+                 (args !? #lower_bound :: Maybe Float),+               ("upper_bound",) . showValue <$>+                 (args !? #upper_bound :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LeakyReLU"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_LeakyReLU_upd ::+               forall args . Fullfilled "_LeakyReLU(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "_LeakyReLU(ndarray)" args -> IO ()+_LeakyReLU_upd outputs args+  = let scalarArgs+          = catMaybes+              [("act_type",) . showValue <$>+                 (args !? #act_type ::+                    Maybe (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])),+               ("slope",) . showValue <$> (args !? #slope :: Maybe Float),+               ("lower_bound",) . showValue <$>+                 (args !? #lower_bound :: Maybe Float),+               ("upper_bound",) . showValue <$>+                 (args !? #upper_bound :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LeakyReLU"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_SwapAxis(ndarray)" =+     '[ '("dim1", AttrOpt Int), '("dim2", AttrOpt Int),+        '("data", AttrOpt NDArrayHandle)]++_SwapAxis ::+          forall args . Fullfilled "_SwapAxis(ndarray)" args =>+            ArgsHMap "_SwapAxis(ndarray)" args -> IO [NDArrayHandle]+_SwapAxis args+  = let scalarArgs+          = catMaybes+              [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int),+               ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SwapAxis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_SwapAxis_upd ::+              forall args . Fullfilled "_SwapAxis(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "_SwapAxis(ndarray)" args -> IO ()+_SwapAxis_upd outputs args+  = let scalarArgs+          = catMaybes+              [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int),+               ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SwapAxis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_IdentityAttachKLSparseReg(ndarray)" =+     '[ '("sparseness_target", AttrOpt Float),+        '("penalty", AttrOpt Float), '("momentum", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle)]++_IdentityAttachKLSparseReg ::+                           forall args .+                             Fullfilled "_IdentityAttachKLSparseReg(ndarray)" args =>+                             ArgsHMap "_IdentityAttachKLSparseReg(ndarray)" args ->+                               IO [NDArrayHandle]+_IdentityAttachKLSparseReg args+  = let scalarArgs+          = catMaybes+              [("sparseness_target",) . showValue <$>+                 (args !? #sparseness_target :: Maybe Float),+               ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "IdentityAttachKLSparseReg"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_IdentityAttachKLSparseReg_upd ::+                               forall args .+                                 Fullfilled "_IdentityAttachKLSparseReg(ndarray)" args =>+                                 [NDArrayHandle] ->+                                   ArgsHMap "_IdentityAttachKLSparseReg(ndarray)" args -> IO ()+_IdentityAttachKLSparseReg_upd outputs args+  = let scalarArgs+          = catMaybes+              [("sparseness_target",) . showValue <$>+                 (args !? #sparseness_target :: Maybe Float),+               ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "IdentityAttachKLSparseReg"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_SliceChannel(ndarray)" =+     '[ '("num_outputs", AttrReq Int), '("axis", AttrOpt Int),+        '("squeeze_axis", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++_SliceChannel ::+              forall args . Fullfilled "_SliceChannel(ndarray)" args =>+                ArgsHMap "_SliceChannel(ndarray)" args -> IO [NDArrayHandle]+_SliceChannel args+  = let scalarArgs+          = catMaybes+              [("num_outputs",) . showValue <$>+                 (args !? #num_outputs :: Maybe Int),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("squeeze_axis",) . showValue <$>+                 (args !? #squeeze_axis :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SliceChannel"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_SliceChannel_upd ::+                  forall args . Fullfilled "_SliceChannel(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_SliceChannel(ndarray)" args -> IO ()+_SliceChannel_upd outputs args+  = let scalarArgs+          = catMaybes+              [("num_outputs",) . showValue <$>+                 (args !? #num_outputs :: Maybe Int),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("squeeze_axis",) . showValue <$>+                 (args !? #squeeze_axis :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SliceChannel"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_BatchNorm_v1(ndarray)" =+     '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float),+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),+        '("output_mean_var", AttrOpt Bool),+        '("data", AttrOpt NDArrayHandle),+        '("gamma", AttrOpt NDArrayHandle),+        '("beta", AttrOpt NDArrayHandle)]++_BatchNorm_v1 ::+              forall args . Fullfilled "_BatchNorm_v1(ndarray)" args =>+                ArgsHMap "_BatchNorm_v1(ndarray)" args -> IO [NDArrayHandle]+_BatchNorm_v1 args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BatchNorm_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_BatchNorm_v1_upd ::+                  forall args . Fullfilled "_BatchNorm_v1(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_BatchNorm_v1(ndarray)" args -> IO ()+_BatchNorm_v1_upd outputs args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BatchNorm_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "signsgd_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle)]++signsgd_update ::+               forall args . Fullfilled "signsgd_update(ndarray)" args =>+                 ArgsHMap "signsgd_update(ndarray)" args -> IO [NDArrayHandle]+signsgd_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "signsgd_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++signsgd_update_upd ::+                   forall args . Fullfilled "signsgd_update(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "signsgd_update(ndarray)" args -> IO ()+signsgd_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "signsgd_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "signum_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("wd_lh", AttrOpt Float),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle)]++signum_update ::+              forall args . Fullfilled "signum_update(ndarray)" args =>+                ArgsHMap "signum_update(ndarray)" args -> IO [NDArrayHandle]+signum_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("wd_lh",) . showValue <$> (args !? #wd_lh :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "signum_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++signum_update_upd ::+                  forall args . Fullfilled "signum_update(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "signum_update(ndarray)" args -> IO ()+signum_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("wd_lh",) . showValue <$> (args !? #wd_lh :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "signum_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "sgd_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle)]++sgd_update ::+           forall args . Fullfilled "sgd_update(ndarray)" args =>+             ArgsHMap "sgd_update(ndarray)" args -> IO [NDArrayHandle]+sgd_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sgd_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++sgd_update_upd ::+               forall args . Fullfilled "sgd_update(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "sgd_update(ndarray)" args -> IO ()+sgd_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sgd_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "sgd_mom_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle)]++sgd_mom_update ::+               forall args . Fullfilled "sgd_mom_update(ndarray)" args =>+                 ArgsHMap "sgd_mom_update(ndarray)" args -> IO [NDArrayHandle]+sgd_mom_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sgd_mom_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++sgd_mom_update_upd ::+                   forall args . Fullfilled "sgd_mom_update(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "sgd_mom_update(ndarray)" args -> IO ()+sgd_mom_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sgd_mom_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "mp_sgd_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle),+        '("weight32", AttrOpt NDArrayHandle)]++mp_sgd_update ::+              forall args . Fullfilled "mp_sgd_update(ndarray)" args =>+                ArgsHMap "mp_sgd_update(ndarray)" args -> IO [NDArrayHandle]+mp_sgd_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mp_sgd_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++mp_sgd_update_upd ::+                  forall args . Fullfilled "mp_sgd_update(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "mp_sgd_update(ndarray)" args -> IO ()+mp_sgd_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mp_sgd_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "mp_sgd_mom_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle),+        '("weight32", AttrOpt NDArrayHandle)]++mp_sgd_mom_update ::+                  forall args . Fullfilled "mp_sgd_mom_update(ndarray)" args =>+                    ArgsHMap "mp_sgd_mom_update(ndarray)" args -> IO [NDArrayHandle]+mp_sgd_mom_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle),+               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mp_sgd_mom_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++mp_sgd_mom_update_upd ::+                      forall args . Fullfilled "mp_sgd_mom_update(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "mp_sgd_mom_update(ndarray)" args -> IO ()+mp_sgd_mom_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle),+               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mp_sgd_mom_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "ftml_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),+        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Double),+        '("t", AttrReq Int), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float), '("clip_grad", AttrOpt Float),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle), '("d", AttrOpt NDArrayHandle),+        '("v", AttrOpt NDArrayHandle), '("z", AttrOpt NDArrayHandle)]++ftml_update ::+            forall args . Fullfilled "ftml_update(ndarray)" args =>+              ArgsHMap "ftml_update(ndarray)" args -> IO [NDArrayHandle]+ftml_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Double),+               ("t",) . showValue <$> (args !? #t :: Maybe Int),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_grad",) . showValue <$> (args !? #clip_grad :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("d",) <$> (args !? #d :: Maybe NDArrayHandle),+               ("v",) <$> (args !? #v :: Maybe NDArrayHandle),+               ("z",) <$> (args !? #z :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ftml_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++ftml_update_upd ::+                forall args . Fullfilled "ftml_update(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "ftml_update(ndarray)" args -> IO ()+ftml_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Double),+               ("t",) . showValue <$> (args !? #t :: Maybe Int),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_grad",) . showValue <$> (args !? #clip_grad :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("d",) <$> (args !? #d :: Maybe NDArrayHandle),+               ("v",) <$> (args !? #v :: Maybe NDArrayHandle),+               ("z",) <$> (args !? #z :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ftml_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "adam_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),+        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle), '("mean", AttrOpt NDArrayHandle),+        '("var", AttrOpt NDArrayHandle)]++adam_update ::+            forall args . Fullfilled "adam_update(ndarray)" args =>+              ArgsHMap "adam_update(ndarray)" args -> IO [NDArrayHandle]+adam_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle),+               ("var",) <$> (args !? #var :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "adam_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++adam_update_upd ::+                forall args . Fullfilled "adam_update(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "adam_update(ndarray)" args -> IO ()+adam_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle),+               ("var",) <$> (args !? #var :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "adam_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "rmsprop_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),+        '("epsilon", AttrOpt Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("clip_weights", AttrOpt Float),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle), '("n", AttrOpt NDArrayHandle)]++rmsprop_update ::+               forall args . Fullfilled "rmsprop_update(ndarray)" args =>+                 ArgsHMap "rmsprop_update(ndarray)" args -> IO [NDArrayHandle]+rmsprop_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("clip_weights",) . showValue <$>+                 (args !? #clip_weights :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("n",) <$> (args !? #n :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rmsprop_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++rmsprop_update_upd ::+                   forall args . Fullfilled "rmsprop_update(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "rmsprop_update(ndarray)" args -> IO ()+rmsprop_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("clip_weights",) . showValue <$>+                 (args !? #clip_weights :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("n",) <$> (args !? #n :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rmsprop_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "rmspropalex_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),+        '("gamma2", AttrOpt Float), '("epsilon", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("clip_weights", AttrOpt Float),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle), '("n", AttrOpt NDArrayHandle),+        '("g", AttrOpt NDArrayHandle), '("delta", AttrOpt NDArrayHandle)]++rmspropalex_update ::+                   forall args . Fullfilled "rmspropalex_update(ndarray)" args =>+                     ArgsHMap "rmspropalex_update(ndarray)" args -> IO [NDArrayHandle]+rmspropalex_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),+               ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("clip_weights",) . showValue <$>+                 (args !? #clip_weights :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("n",) <$> (args !? #n :: Maybe NDArrayHandle),+               ("g",) <$> (args !? #g :: Maybe NDArrayHandle),+               ("delta",) <$> (args !? #delta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rmspropalex_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++rmspropalex_update_upd ::+                       forall args . Fullfilled "rmspropalex_update(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "rmspropalex_update(ndarray)" args -> IO ()+rmspropalex_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),+               ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("clip_weights",) . showValue <$>+                 (args !? #clip_weights :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("n",) <$> (args !? #n :: Maybe NDArrayHandle),+               ("g",) <$> (args !? #g :: Maybe NDArrayHandle),+               ("delta",) <$> (args !? #delta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rmspropalex_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "ftrl_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("lamda1", AttrOpt Float),+        '("beta", AttrOpt Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle), '("z", AttrOpt NDArrayHandle),+        '("n", AttrOpt NDArrayHandle)]++ftrl_update ::+            forall args . Fullfilled "ftrl_update(ndarray)" args =>+              ArgsHMap "ftrl_update(ndarray)" args -> IO [NDArrayHandle]+ftrl_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("z",) <$> (args !? #z :: Maybe NDArrayHandle),+               ("n",) <$> (args !? #n :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ftrl_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++ftrl_update_upd ::+                forall args . Fullfilled "ftrl_update(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "ftrl_update(ndarray)" args -> IO ()+ftrl_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("z",) <$> (args !? #z :: Maybe NDArrayHandle),+               ("n",) <$> (args !? #n :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ftrl_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_sparse_adagrad_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("epsilon", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle),+        '("history", AttrOpt NDArrayHandle)]++_sparse_adagrad_update ::+                       forall args . Fullfilled "_sparse_adagrad_update(ndarray)" args =>+                         ArgsHMap "_sparse_adagrad_update(ndarray)" args ->+                           IO [NDArrayHandle]+_sparse_adagrad_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("history",) <$> (args !? #history :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sparse_adagrad_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sparse_adagrad_update_upd ::+                           forall args . Fullfilled "_sparse_adagrad_update(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_sparse_adagrad_update(ndarray)" args -> IO ()+_sparse_adagrad_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("history",) <$> (args !? #history :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sparse_adagrad_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_LinearRegressionOutput(ndarray)" =+     '[ '("grad_scale", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle),+        '("label", AttrOpt NDArrayHandle)]++_LinearRegressionOutput ::+                        forall args . Fullfilled "_LinearRegressionOutput(ndarray)" args =>+                          ArgsHMap "_LinearRegressionOutput(ndarray)" args ->+                            IO [NDArrayHandle]+_LinearRegressionOutput args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LinearRegressionOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_LinearRegressionOutput_upd ::+                            forall args . Fullfilled "_LinearRegressionOutput(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_LinearRegressionOutput(ndarray)" args -> IO ()+_LinearRegressionOutput_upd outputs args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LinearRegressionOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linear_reg_out(ndarray)" =+     '[]++_backward_linear_reg_out ::+                         forall args .+                           Fullfilled "_backward_linear_reg_out(ndarray)" args =>+                           ArgsHMap "_backward_linear_reg_out(ndarray)" args ->+                             IO [NDArrayHandle]+_backward_linear_reg_out args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linear_reg_out"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linear_reg_out_upd ::+                             forall args .+                               Fullfilled "_backward_linear_reg_out(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_backward_linear_reg_out(ndarray)" args -> IO ()+_backward_linear_reg_out_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linear_reg_out"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_MAERegressionOutput(ndarray)" =+     '[ '("grad_scale", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle),+        '("label", AttrOpt NDArrayHandle)]++_MAERegressionOutput ::+                     forall args . Fullfilled "_MAERegressionOutput(ndarray)" args =>+                       ArgsHMap "_MAERegressionOutput(ndarray)" args -> IO [NDArrayHandle]+_MAERegressionOutput args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "MAERegressionOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_MAERegressionOutput_upd ::+                         forall args . Fullfilled "_MAERegressionOutput(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_MAERegressionOutput(ndarray)" args -> IO ()+_MAERegressionOutput_upd outputs args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "MAERegressionOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_mae_reg_out(ndarray)" = '[]++_backward_mae_reg_out ::+                      forall args . Fullfilled "_backward_mae_reg_out(ndarray)" args =>+                        ArgsHMap "_backward_mae_reg_out(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_mae_reg_out args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mae_reg_out"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_mae_reg_out_upd ::+                          forall args . Fullfilled "_backward_mae_reg_out(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_mae_reg_out(ndarray)" args -> IO ()+_backward_mae_reg_out_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mae_reg_out"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_LogisticRegressionOutput(ndarray)" =+     '[ '("grad_scale", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle),+        '("label", AttrOpt NDArrayHandle)]++_LogisticRegressionOutput ::+                          forall args .+                            Fullfilled "_LogisticRegressionOutput(ndarray)" args =>+                            ArgsHMap "_LogisticRegressionOutput(ndarray)" args ->+                              IO [NDArrayHandle]+_LogisticRegressionOutput args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LogisticRegressionOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_LogisticRegressionOutput_upd ::+                              forall args .+                                Fullfilled "_LogisticRegressionOutput(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_LogisticRegressionOutput(ndarray)" args -> IO ()+_LogisticRegressionOutput_upd outputs args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LogisticRegressionOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_logistic_reg_out(ndarray)" =+     '[]++_backward_logistic_reg_out ::+                           forall args .+                             Fullfilled "_backward_logistic_reg_out(ndarray)" args =>+                             ArgsHMap "_backward_logistic_reg_out(ndarray)" args ->+                               IO [NDArrayHandle]+_backward_logistic_reg_out args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_logistic_reg_out"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_logistic_reg_out_upd ::+                               forall args .+                                 Fullfilled "_backward_logistic_reg_out(ndarray)" args =>+                                 [NDArrayHandle] ->+                                   ArgsHMap "_backward_logistic_reg_out(ndarray)" args -> IO ()+_backward_logistic_reg_out_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_logistic_reg_out"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_CustomFunction(ndarray)" = '[]++_CustomFunction ::+                forall args . Fullfilled "_CustomFunction(ndarray)" args =>+                  ArgsHMap "_CustomFunction(ndarray)" args -> IO [NDArrayHandle]+_CustomFunction args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_CustomFunction"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_CustomFunction_upd ::+                    forall args . Fullfilled "_CustomFunction(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_CustomFunction(ndarray)" args -> IO ()+_CustomFunction_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_CustomFunction"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_CustomFunction(ndarray)" =+     '[]++_backward_CustomFunction ::+                         forall args .+                           Fullfilled "_backward_CustomFunction(ndarray)" args =>+                           ArgsHMap "_backward_CustomFunction(ndarray)" args ->+                             IO [NDArrayHandle]+_backward_CustomFunction args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_CustomFunction"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_CustomFunction_upd ::+                             forall args .+                               Fullfilled "_backward_CustomFunction(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_backward_CustomFunction(ndarray)" args -> IO ()+_backward_CustomFunction_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_CustomFunction"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward__Native(ndarray)" = '[]++_backward__Native ::+                  forall args . Fullfilled "_backward__Native(ndarray)" args =>+                    ArgsHMap "_backward__Native(ndarray)" args -> IO [NDArrayHandle]+_backward__Native args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__Native"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__Native_upd ::+                      forall args . Fullfilled "_backward__Native(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward__Native(ndarray)" args -> IO ()+_backward__Native_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__Native"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward__NDArray(ndarray)" = '[]++_backward__NDArray ::+                   forall args . Fullfilled "_backward__NDArray(ndarray)" args =>+                     ArgsHMap "_backward__NDArray(ndarray)" args -> IO [NDArrayHandle]+_backward__NDArray args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__NDArray"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__NDArray_upd ::+                       forall args . Fullfilled "_backward__NDArray(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_backward__NDArray(ndarray)" args -> IO ()+_backward__NDArray_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__NDArray"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_MultiBoxTarget(ndarray)" =+     '[ '("overlap_threshold", AttrOpt Float),+        '("ignore_label", AttrOpt Float),+        '("negative_mining_ratio", AttrOpt Float),+        '("negative_mining_thresh", AttrOpt Float),+        '("minimum_negative_samples", AttrOpt Int),+        '("variances", AttrOpt [Float]),+        '("anchor", AttrOpt NDArrayHandle),+        '("label", AttrOpt NDArrayHandle),+        '("cls_pred", AttrOpt NDArrayHandle)]++_contrib_MultiBoxTarget ::+                        forall args . Fullfilled "_contrib_MultiBoxTarget(ndarray)" args =>+                          ArgsHMap "_contrib_MultiBoxTarget(ndarray)" args ->+                            IO [NDArrayHandle]+_contrib_MultiBoxTarget args+  = let scalarArgs+          = catMaybes+              [("overlap_threshold",) . showValue <$>+                 (args !? #overlap_threshold :: Maybe Float),+               ("ignore_label",) . showValue <$>+                 (args !? #ignore_label :: Maybe Float),+               ("negative_mining_ratio",) . showValue <$>+                 (args !? #negative_mining_ratio :: Maybe Float),+               ("negative_mining_thresh",) . showValue <$>+                 (args !? #negative_mining_thresh :: Maybe Float),+               ("minimum_negative_samples",) . showValue <$>+                 (args !? #minimum_negative_samples :: Maybe Int),+               ("variances",) . showValue <$>+                 (args !? #variances :: Maybe [Float])]+        tensorArgs+          = catMaybes+              [("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle),+               ("cls_pred",) <$> (args !? #cls_pred :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxTarget"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_MultiBoxTarget_upd ::+                            forall args . Fullfilled "_contrib_MultiBoxTarget(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_contrib_MultiBoxTarget(ndarray)" args -> IO ()+_contrib_MultiBoxTarget_upd outputs args+  = let scalarArgs+          = catMaybes+              [("overlap_threshold",) . showValue <$>+                 (args !? #overlap_threshold :: Maybe Float),+               ("ignore_label",) . showValue <$>+                 (args !? #ignore_label :: Maybe Float),+               ("negative_mining_ratio",) . showValue <$>+                 (args !? #negative_mining_ratio :: Maybe Float),+               ("negative_mining_thresh",) . showValue <$>+                 (args !? #negative_mining_thresh :: Maybe Float),+               ("minimum_negative_samples",) . showValue <$>+                 (args !? #minimum_negative_samples :: Maybe Int),+               ("variances",) . showValue <$>+                 (args !? #variances :: Maybe [Float])]+        tensorArgs+          = catMaybes+              [("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle),+               ("cls_pred",) <$> (args !? #cls_pred :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxTarget"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward__contrib_MultiBoxTarget(ndarray)" = '[]++_backward__contrib_MultiBoxTarget ::+                                  forall args .+                                    Fullfilled "_backward__contrib_MultiBoxTarget(ndarray)" args =>+                                    ArgsHMap "_backward__contrib_MultiBoxTarget(ndarray)" args ->+                                      IO [NDArrayHandle]+_backward__contrib_MultiBoxTarget args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_MultiBoxTarget_upd ::+                                      forall args .+                                        Fullfilled "_backward__contrib_MultiBoxTarget(ndarray)"+                                          args =>+                                        [NDArrayHandle] ->+                                          ArgsHMap "_backward__contrib_MultiBoxTarget(ndarray)" args+                                            -> IO ()+_backward__contrib_MultiBoxTarget_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_Proposal(ndarray)" =+     '[ '("rpn_pre_nms_top_n", AttrOpt Int),+        '("rpn_post_nms_top_n", AttrOpt Int),+        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),+        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),+        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),+        '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt NDArrayHandle),+        '("bbox_pred", AttrOpt NDArrayHandle),+        '("im_info", AttrOpt NDArrayHandle)]++_contrib_Proposal ::+                  forall args . Fullfilled "_contrib_Proposal(ndarray)" args =>+                    ArgsHMap "_contrib_Proposal(ndarray)" args -> IO [NDArrayHandle]+_contrib_Proposal args+  = let scalarArgs+          = catMaybes+              [("rpn_pre_nms_top_n",) . showValue <$>+                 (args !? #rpn_pre_nms_top_n :: Maybe Int),+               ("rpn_post_nms_top_n",) . showValue <$>+                 (args !? #rpn_post_nms_top_n :: Maybe Int),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("rpn_min_size",) . showValue <$>+                 (args !? #rpn_min_size :: Maybe Int),+               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("feature_stride",) . showValue <$>+                 (args !? #feature_stride :: Maybe Int),+               ("output_score",) . showValue <$>+                 (args !? #output_score :: Maybe Bool),+               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),+               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle),+               ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_Proposal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_Proposal_upd ::+                      forall args . Fullfilled "_contrib_Proposal(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_contrib_Proposal(ndarray)" args -> IO ()+_contrib_Proposal_upd outputs args+  = let scalarArgs+          = catMaybes+              [("rpn_pre_nms_top_n",) . showValue <$>+                 (args !? #rpn_pre_nms_top_n :: Maybe Int),+               ("rpn_post_nms_top_n",) . showValue <$>+                 (args !? #rpn_post_nms_top_n :: Maybe Int),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("rpn_min_size",) . showValue <$>+                 (args !? #rpn_min_size :: Maybe Int),+               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("feature_stride",) . showValue <$>+                 (args !? #feature_stride :: Maybe Int),+               ("output_score",) . showValue <$>+                 (args !? #output_score :: Maybe Bool),+               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),+               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle),+               ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_Proposal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward__contrib_Proposal(ndarray)"+     = '[]++_backward__contrib_Proposal ::+                            forall args .+                              Fullfilled "_backward__contrib_Proposal(ndarray)" args =>+                              ArgsHMap "_backward__contrib_Proposal(ndarray)" args ->+                                IO [NDArrayHandle]+_backward__contrib_Proposal args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_Proposal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_Proposal_upd ::+                                forall args .+                                  Fullfilled "_backward__contrib_Proposal(ndarray)" args =>+                                  [NDArrayHandle] ->+                                    ArgsHMap "_backward__contrib_Proposal(ndarray)" args -> IO ()+_backward__contrib_Proposal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_Proposal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_count_sketch(ndarray)" =+     '[ '("out_dim", AttrReq Int),+        '("processing_batch_size", AttrOpt Int),+        '("data", AttrOpt NDArrayHandle), '("h", AttrOpt NDArrayHandle),+        '("s", AttrOpt NDArrayHandle)]++_contrib_count_sketch ::+                      forall args . Fullfilled "_contrib_count_sketch(ndarray)" args =>+                        ArgsHMap "_contrib_count_sketch(ndarray)" args ->+                          IO [NDArrayHandle]+_contrib_count_sketch args+  = let scalarArgs+          = catMaybes+              [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int),+               ("processing_batch_size",) . showValue <$>+                 (args !? #processing_batch_size :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("h",) <$> (args !? #h :: Maybe NDArrayHandle),+               ("s",) <$> (args !? #s :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_count_sketch"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_count_sketch_upd ::+                          forall args . Fullfilled "_contrib_count_sketch(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_contrib_count_sketch(ndarray)" args -> IO ()+_contrib_count_sketch_upd outputs args+  = let scalarArgs+          = catMaybes+              [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int),+               ("processing_batch_size",) . showValue <$>+                 (args !? #processing_batch_size :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("h",) <$> (args !? #h :: Maybe NDArrayHandle),+               ("s",) <$> (args !? #s :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_count_sketch"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward__contrib_count_sketch(ndarray)" = '[]++_backward__contrib_count_sketch ::+                                forall args .+                                  Fullfilled "_backward__contrib_count_sketch(ndarray)" args =>+                                  ArgsHMap "_backward__contrib_count_sketch(ndarray)" args ->+                                    IO [NDArrayHandle]+_backward__contrib_count_sketch args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_count_sketch"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_count_sketch_upd ::+                                    forall args .+                                      Fullfilled "_backward__contrib_count_sketch(ndarray)" args =>+                                      [NDArrayHandle] ->+                                        ArgsHMap "_backward__contrib_count_sketch(ndarray)" args ->+                                          IO ()+_backward__contrib_count_sketch_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_count_sketch"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_MultiBoxDetection(ndarray)" =+     '[ '("clip", AttrOpt Bool), '("threshold", AttrOpt Float),+        '("background_id", AttrOpt Int), '("nms_threshold", AttrOpt Float),+        '("force_suppress", AttrOpt Bool), '("variances", AttrOpt [Float]),+        '("nms_topk", AttrOpt Int), '("cls_prob", AttrOpt NDArrayHandle),+        '("loc_pred", AttrOpt NDArrayHandle),+        '("anchor", AttrOpt NDArrayHandle)]++_contrib_MultiBoxDetection ::+                           forall args .+                             Fullfilled "_contrib_MultiBoxDetection(ndarray)" args =>+                             ArgsHMap "_contrib_MultiBoxDetection(ndarray)" args ->+                               IO [NDArrayHandle]+_contrib_MultiBoxDetection args+  = let scalarArgs+          = catMaybes+              [("clip",) . showValue <$> (args !? #clip :: Maybe Bool),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("background_id",) . showValue <$>+                 (args !? #background_id :: Maybe Int),+               ("nms_threshold",) . showValue <$>+                 (args !? #nms_threshold :: Maybe Float),+               ("force_suppress",) . showValue <$>+                 (args !? #force_suppress :: Maybe Bool),+               ("variances",) . showValue <$>+                 (args !? #variances :: Maybe [Float]),+               ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),+               ("loc_pred",) <$> (args !? #loc_pred :: Maybe NDArrayHandle),+               ("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxDetection"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_MultiBoxDetection_upd ::+                               forall args .+                                 Fullfilled "_contrib_MultiBoxDetection(ndarray)" args =>+                                 [NDArrayHandle] ->+                                   ArgsHMap "_contrib_MultiBoxDetection(ndarray)" args -> IO ()+_contrib_MultiBoxDetection_upd outputs args+  = let scalarArgs+          = catMaybes+              [("clip",) . showValue <$> (args !? #clip :: Maybe Bool),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("background_id",) . showValue <$>+                 (args !? #background_id :: Maybe Int),+               ("nms_threshold",) . showValue <$>+                 (args !? #nms_threshold :: Maybe Float),+               ("force_suppress",) . showValue <$>+                 (args !? #force_suppress :: Maybe Bool),+               ("variances",) . showValue <$>+                 (args !? #variances :: Maybe [Float]),+               ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),+               ("loc_pred",) <$> (args !? #loc_pred :: Maybe NDArrayHandle),+               ("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxDetection"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward__contrib_MultiBoxDetection(ndarray)" = '[]++_backward__contrib_MultiBoxDetection ::+                                     forall args .+                                       Fullfilled "_backward__contrib_MultiBoxDetection(ndarray)"+                                         args =>+                                       ArgsHMap "_backward__contrib_MultiBoxDetection(ndarray)" args+                                         -> IO [NDArrayHandle]+_backward__contrib_MultiBoxDetection args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_MultiBoxDetection_upd ::+                                         forall args .+                                           Fullfilled+                                             "_backward__contrib_MultiBoxDetection(ndarray)" args =>+                                           [NDArrayHandle] ->+                                             ArgsHMap+                                               "_backward__contrib_MultiBoxDetection(ndarray)"+                                               args+                                               -> IO ()+_backward__contrib_MultiBoxDetection_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward__contrib_DeformablePSROIPooling(ndarray)"+     = '[]++_backward__contrib_DeformablePSROIPooling ::+                                          forall args .+                                            Fullfilled+                                              "_backward__contrib_DeformablePSROIPooling(ndarray)"+                                              args =>+                                            ArgsHMap+                                              "_backward__contrib_DeformablePSROIPooling(ndarray)"+                                              args+                                              -> IO [NDArrayHandle]+_backward__contrib_DeformablePSROIPooling args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_DeformablePSROIPooling_upd ::+                                              forall args .+                                                Fullfilled+                                                  "_backward__contrib_DeformablePSROIPooling(ndarray)"+                                                  args =>+                                                [NDArrayHandle] ->+                                                  ArgsHMap+                                                    "_backward__contrib_DeformablePSROIPooling(ndarray)"+                                                    args+                                                    -> IO ()+_backward__contrib_DeformablePSROIPooling_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_fft(ndarray)" =+     '[ '("compute_size", AttrOpt Int),+        '("data", AttrOpt NDArrayHandle)]++_contrib_fft ::+             forall args . Fullfilled "_contrib_fft(ndarray)" args =>+               ArgsHMap "_contrib_fft(ndarray)" args -> IO [NDArrayHandle]+_contrib_fft args+  = let scalarArgs+          = catMaybes+              [("compute_size",) . showValue <$>+                 (args !? #compute_size :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_fft"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_fft_upd ::+                 forall args . Fullfilled "_contrib_fft(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_contrib_fft(ndarray)" args -> IO ()+_contrib_fft_upd outputs args+  = let scalarArgs+          = catMaybes+              [("compute_size",) . showValue <$>+                 (args !? #compute_size :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_fft"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward__contrib_fft(ndarray)" = '[]++_backward__contrib_fft ::+                       forall args . Fullfilled "_backward__contrib_fft(ndarray)" args =>+                         ArgsHMap "_backward__contrib_fft(ndarray)" args ->+                           IO [NDArrayHandle]+_backward__contrib_fft args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_fft"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_fft_upd ::+                           forall args . Fullfilled "_backward__contrib_fft(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward__contrib_fft(ndarray)" args -> IO ()+_backward__contrib_fft_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_fft"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_MultiBoxPrior(ndarray)" =+     '[ '("sizes", AttrOpt [Float]), '("ratios", AttrOpt [Float]),+        '("clip", AttrOpt Bool), '("steps", AttrOpt [Float]),+        '("offsets", AttrOpt [Float]), '("data", AttrOpt NDArrayHandle)]++_contrib_MultiBoxPrior ::+                       forall args . Fullfilled "_contrib_MultiBoxPrior(ndarray)" args =>+                         ArgsHMap "_contrib_MultiBoxPrior(ndarray)" args ->+                           IO [NDArrayHandle]+_contrib_MultiBoxPrior args+  = let scalarArgs+          = catMaybes+              [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("clip",) . showValue <$> (args !? #clip :: Maybe Bool),+               ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]),+               ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxPrior"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_MultiBoxPrior_upd ::+                           forall args . Fullfilled "_contrib_MultiBoxPrior(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_contrib_MultiBoxPrior(ndarray)" args -> IO ()+_contrib_MultiBoxPrior_upd outputs args+  = let scalarArgs+          = catMaybes+              [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("clip",) . showValue <$> (args !? #clip :: Maybe Bool),+               ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]),+               ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxPrior"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward__contrib_MultiBoxPrior(ndarray)" = '[]++_backward__contrib_MultiBoxPrior ::+                                 forall args .+                                   Fullfilled "_backward__contrib_MultiBoxPrior(ndarray)" args =>+                                   ArgsHMap "_backward__contrib_MultiBoxPrior(ndarray)" args ->+                                     IO [NDArrayHandle]+_backward__contrib_MultiBoxPrior args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_MultiBoxPrior_upd ::+                                     forall args .+                                       Fullfilled "_backward__contrib_MultiBoxPrior(ndarray)"+                                         args =>+                                       [NDArrayHandle] ->+                                         ArgsHMap "_backward__contrib_MultiBoxPrior(ndarray)" args+                                           -> IO ()+_backward__contrib_MultiBoxPrior_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_MultiProposal(ndarray)" =+     '[ '("rpn_pre_nms_top_n", AttrOpt Int),+        '("rpn_post_nms_top_n", AttrOpt Int),+        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),+        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),+        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),+        '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt NDArrayHandle),+        '("bbox_pred", AttrOpt NDArrayHandle),+        '("im_info", AttrOpt NDArrayHandle)]++_contrib_MultiProposal ::+                       forall args . Fullfilled "_contrib_MultiProposal(ndarray)" args =>+                         ArgsHMap "_contrib_MultiProposal(ndarray)" args ->+                           IO [NDArrayHandle]+_contrib_MultiProposal args+  = let scalarArgs+          = catMaybes+              [("rpn_pre_nms_top_n",) . showValue <$>+                 (args !? #rpn_pre_nms_top_n :: Maybe Int),+               ("rpn_post_nms_top_n",) . showValue <$>+                 (args !? #rpn_post_nms_top_n :: Maybe Int),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("rpn_min_size",) . showValue <$>+                 (args !? #rpn_min_size :: Maybe Int),+               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("feature_stride",) . showValue <$>+                 (args !? #feature_stride :: Maybe Int),+               ("output_score",) . showValue <$>+                 (args !? #output_score :: Maybe Bool),+               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),+               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle),+               ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiProposal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_MultiProposal_upd ::+                           forall args . Fullfilled "_contrib_MultiProposal(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_contrib_MultiProposal(ndarray)" args -> IO ()+_contrib_MultiProposal_upd outputs args+  = let scalarArgs+          = catMaybes+              [("rpn_pre_nms_top_n",) . showValue <$>+                 (args !? #rpn_pre_nms_top_n :: Maybe Int),+               ("rpn_post_nms_top_n",) . showValue <$>+                 (args !? #rpn_post_nms_top_n :: Maybe Int),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("rpn_min_size",) . showValue <$>+                 (args !? #rpn_min_size :: Maybe Int),+               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("feature_stride",) . showValue <$>+                 (args !? #feature_stride :: Maybe Int),+               ("output_score",) . showValue <$>+                 (args !? #output_score :: Maybe Bool),+               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),+               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle),+               ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiProposal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward__contrib_MultiProposal(ndarray)" = '[]++_backward__contrib_MultiProposal ::+                                 forall args .+                                   Fullfilled "_backward__contrib_MultiProposal(ndarray)" args =>+                                   ArgsHMap "_backward__contrib_MultiProposal(ndarray)" args ->+                                     IO [NDArrayHandle]+_backward__contrib_MultiProposal args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiProposal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_MultiProposal_upd ::+                                     forall args .+                                       Fullfilled "_backward__contrib_MultiProposal(ndarray)"+                                         args =>+                                       [NDArrayHandle] ->+                                         ArgsHMap "_backward__contrib_MultiProposal(ndarray)" args+                                           -> IO ()+_backward__contrib_MultiProposal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiProposal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward__contrib_PSROIPooling(ndarray)" = '[]++_backward__contrib_PSROIPooling ::+                                forall args .+                                  Fullfilled "_backward__contrib_PSROIPooling(ndarray)" args =>+                                  ArgsHMap "_backward__contrib_PSROIPooling(ndarray)" args ->+                                    IO [NDArrayHandle]+_backward__contrib_PSROIPooling args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_PSROIPooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_PSROIPooling_upd ::+                                    forall args .+                                      Fullfilled "_backward__contrib_PSROIPooling(ndarray)" args =>+                                      [NDArrayHandle] ->+                                        ArgsHMap "_backward__contrib_PSROIPooling(ndarray)" args ->+                                          IO ()+_backward__contrib_PSROIPooling_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_PSROIPooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_contrib_DeformableConvolution(ndarray)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("num_deformable_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("layout", AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NCW"]))),+        '("data", AttrOpt NDArrayHandle),+        '("offset", AttrOpt NDArrayHandle),+        '("weight", AttrOpt NDArrayHandle),+        '("bias", AttrOpt NDArrayHandle)]++_contrib_DeformableConvolution ::+                               forall args .+                                 Fullfilled "_contrib_DeformableConvolution(ndarray)" args =>+                                 ArgsHMap "_contrib_DeformableConvolution(ndarray)" args ->+                                   IO [NDArrayHandle]+_contrib_DeformableConvolution args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("num_deformable_group",) . showValue <$>+                 (args !? #num_deformable_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("offset",) <$> (args !? #offset :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_DeformableConvolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_DeformableConvolution_upd ::+                                   forall args .+                                     Fullfilled "_contrib_DeformableConvolution(ndarray)" args =>+                                     [NDArrayHandle] ->+                                       ArgsHMap "_contrib_DeformableConvolution(ndarray)" args ->+                                         IO ()+_contrib_DeformableConvolution_upd outputs args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("num_deformable_group",) . showValue <$>+                 (args !? #num_deformable_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("offset",) <$> (args !? #offset :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_DeformableConvolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward__contrib_DeformableConvolution(ndarray)" =+     '[]++_backward__contrib_DeformableConvolution ::+                                         forall args .+                                           Fullfilled+                                             "_backward__contrib_DeformableConvolution(ndarray)"+                                             args =>+                                           ArgsHMap+                                             "_backward__contrib_DeformableConvolution(ndarray)"+                                             args+                                             -> IO [NDArrayHandle]+_backward__contrib_DeformableConvolution args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_DeformableConvolution_upd ::+                                             forall args .+                                               Fullfilled+                                                 "_backward__contrib_DeformableConvolution(ndarray)"+                                                 args =>+                                               [NDArrayHandle] ->+                                                 ArgsHMap+                                                   "_backward__contrib_DeformableConvolution(ndarray)"+                                                   args+                                                   -> IO ()+_backward__contrib_DeformableConvolution_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_ifft(ndarray)" =+     '[ '("compute_size", AttrOpt Int),+        '("data", AttrOpt NDArrayHandle)]++_contrib_ifft ::+              forall args . Fullfilled "_contrib_ifft(ndarray)" args =>+                ArgsHMap "_contrib_ifft(ndarray)" args -> IO [NDArrayHandle]+_contrib_ifft args+  = let scalarArgs+          = catMaybes+              [("compute_size",) . showValue <$>+                 (args !? #compute_size :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_ifft"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_ifft_upd ::+                  forall args . Fullfilled "_contrib_ifft(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_contrib_ifft(ndarray)" args -> IO ()+_contrib_ifft_upd outputs args+  = let scalarArgs+          = catMaybes+              [("compute_size",) . showValue <$>+                 (args !? #compute_size :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_ifft"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward__contrib_ifft(ndarray)" =+     '[]++_backward__contrib_ifft ::+                        forall args . Fullfilled "_backward__contrib_ifft(ndarray)" args =>+                          ArgsHMap "_backward__contrib_ifft(ndarray)" args ->+                            IO [NDArrayHandle]+_backward__contrib_ifft args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_ifft"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_ifft_upd ::+                            forall args . Fullfilled "_backward__contrib_ifft(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward__contrib_ifft(ndarray)" args -> IO ()+_backward__contrib_ifft_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_ifft"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward__contrib_SyncBatchNorm(ndarray)" = '[]++_backward__contrib_SyncBatchNorm ::+                                 forall args .+                                   Fullfilled "_backward__contrib_SyncBatchNorm(ndarray)" args =>+                                   ArgsHMap "_backward__contrib_SyncBatchNorm(ndarray)" args ->+                                     IO [NDArrayHandle]+_backward__contrib_SyncBatchNorm args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_SyncBatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_SyncBatchNorm_upd ::+                                     forall args .+                                       Fullfilled "_backward__contrib_SyncBatchNorm(ndarray)"+                                         args =>+                                       [NDArrayHandle] ->+                                         ArgsHMap "_backward__contrib_SyncBatchNorm(ndarray)" args+                                           -> IO ()+_backward__contrib_SyncBatchNorm_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_SyncBatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_InstanceNorm(ndarray)" =+     '[ '("eps", AttrOpt Float), '("data", AttrOpt NDArrayHandle),+        '("gamma", AttrOpt NDArrayHandle),+        '("beta", AttrOpt NDArrayHandle)]++_InstanceNorm ::+              forall args . Fullfilled "_InstanceNorm(ndarray)" args =>+                ArgsHMap "_InstanceNorm(ndarray)" args -> IO [NDArrayHandle]+_InstanceNorm args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "InstanceNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_InstanceNorm_upd ::+                  forall args . Fullfilled "_InstanceNorm(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_InstanceNorm(ndarray)" args -> IO ()+_InstanceNorm_upd outputs args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "InstanceNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_InstanceNorm(ndarray)" = '[]++_backward_InstanceNorm ::+                       forall args . Fullfilled "_backward_InstanceNorm(ndarray)" args =>+                         ArgsHMap "_backward_InstanceNorm(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_InstanceNorm args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_InstanceNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_InstanceNorm_upd ::+                           forall args . Fullfilled "_backward_InstanceNorm(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_InstanceNorm(ndarray)" args -> IO ()+_backward_InstanceNorm_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_InstanceNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_SVMOutput(ndarray)" =+     '[ '("margin", AttrOpt Float),+        '("regularization_coefficient", AttrOpt Float),+        '("use_linear", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),+        '("label", AttrOpt NDArrayHandle)]++_SVMOutput ::+           forall args . Fullfilled "_SVMOutput(ndarray)" args =>+             ArgsHMap "_SVMOutput(ndarray)" args -> IO [NDArrayHandle]+_SVMOutput args+  = let scalarArgs+          = catMaybes+              [("margin",) . showValue <$> (args !? #margin :: Maybe Float),+               ("regularization_coefficient",) . showValue <$>+                 (args !? #regularization_coefficient :: Maybe Float),+               ("use_linear",) . showValue <$>+                 (args !? #use_linear :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SVMOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_SVMOutput_upd ::+               forall args . Fullfilled "_SVMOutput(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "_SVMOutput(ndarray)" args -> IO ()+_SVMOutput_upd outputs args+  = let scalarArgs+          = catMaybes+              [("margin",) . showValue <$> (args !? #margin :: Maybe Float),+               ("regularization_coefficient",) . showValue <$>+                 (args !? #regularization_coefficient :: Maybe Float),+               ("use_linear",) . showValue <$>+                 (args !? #use_linear :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SVMOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SVMOutput(ndarray)" = '[]++_backward_SVMOutput ::+                    forall args . Fullfilled "_backward_SVMOutput(ndarray)" args =>+                      ArgsHMap "_backward_SVMOutput(ndarray)" args -> IO [NDArrayHandle]+_backward_SVMOutput args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SVMOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SVMOutput_upd ::+                        forall args . Fullfilled "_backward_SVMOutput(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_backward_SVMOutput(ndarray)" args -> IO ()+_backward_SVMOutput_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SVMOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_GridGenerator(ndarray)" =+     '[ '("transform_type", AttrReq (EnumType '["affine", "warp"])),+        '("target_shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]++_GridGenerator ::+               forall args . Fullfilled "_GridGenerator(ndarray)" args =>+                 ArgsHMap "_GridGenerator(ndarray)" args -> IO [NDArrayHandle]+_GridGenerator args+  = let scalarArgs+          = catMaybes+              [("transform_type",) . showValue <$>+                 (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "GridGenerator"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_GridGenerator_upd ::+                   forall args . Fullfilled "_GridGenerator(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_GridGenerator(ndarray)" args -> IO ()+_GridGenerator_upd outputs args+  = let scalarArgs+          = catMaybes+              [("transform_type",) . showValue <$>+                 (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "GridGenerator"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_GridGenerator(ndarray)" =+     '[]++_backward_GridGenerator ::+                        forall args . Fullfilled "_backward_GridGenerator(ndarray)" args =>+                          ArgsHMap "_backward_GridGenerator(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_GridGenerator args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_GridGenerator"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_GridGenerator_upd ::+                            forall args . Fullfilled "_backward_GridGenerator(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_GridGenerator(ndarray)" args -> IO ()+_backward_GridGenerator_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_GridGenerator"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Pad(ndarray)" = '[]++_backward_Pad ::+              forall args . Fullfilled "_backward_Pad(ndarray)" args =>+                ArgsHMap "_backward_Pad(ndarray)" args -> IO [NDArrayHandle]+_backward_Pad args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pad"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Pad_upd ::+                  forall args . Fullfilled "_backward_Pad(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_Pad(ndarray)" args -> IO ()+_backward_Pad_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pad"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Convolution_v1(ndarray)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("cudnn_tune",+          AttrOpt+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+        '("cudnn_off", AttrOpt Bool),+        '("layout",+          AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"]))),+        '("data", AttrOpt NDArrayHandle),+        '("weight", AttrOpt NDArrayHandle),+        '("bias", AttrOpt NDArrayHandle)]++_Convolution_v1 ::+                forall args . Fullfilled "_Convolution_v1(ndarray)" args =>+                  ArgsHMap "_Convolution_v1(ndarray)" args -> IO [NDArrayHandle]+_Convolution_v1 args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Convolution_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Convolution_v1_upd ::+                    forall args . Fullfilled "_Convolution_v1(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_Convolution_v1(ndarray)" args -> IO ()+_Convolution_v1_upd outputs args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Convolution_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Convolution_v1(ndarray)" =+     '[]++_backward_Convolution_v1 ::+                         forall args .+                           Fullfilled "_backward_Convolution_v1(ndarray)" args =>+                           ArgsHMap "_backward_Convolution_v1(ndarray)" args ->+                             IO [NDArrayHandle]+_backward_Convolution_v1 args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Convolution_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Convolution_v1_upd ::+                             forall args .+                               Fullfilled "_backward_Convolution_v1(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_backward_Convolution_v1(ndarray)" args -> IO ()+_backward_Convolution_v1_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Convolution_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_SequenceReverse(ndarray)" =+     '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int),+        '("data", AttrOpt NDArrayHandle),+        '("sequence_length", AttrOpt NDArrayHandle)]++_SequenceReverse ::+                 forall args . Fullfilled "_SequenceReverse(ndarray)" args =>+                   ArgsHMap "_SequenceReverse(ndarray)" args -> IO [NDArrayHandle]+_SequenceReverse args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceReverse"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_SequenceReverse_upd ::+                     forall args . Fullfilled "_SequenceReverse(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_SequenceReverse(ndarray)" args -> IO ()+_SequenceReverse_upd outputs args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceReverse"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SequenceReverse(ndarray)" =+     '[]++_backward_SequenceReverse ::+                          forall args .+                            Fullfilled "_backward_SequenceReverse(ndarray)" args =>+                            ArgsHMap "_backward_SequenceReverse(ndarray)" args ->+                              IO [NDArrayHandle]+_backward_SequenceReverse args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceReverse"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SequenceReverse_upd ::+                              forall args .+                                Fullfilled "_backward_SequenceReverse(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_backward_SequenceReverse(ndarray)" args -> IO ()+_backward_SequenceReverse_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceReverse"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_SoftmaxOutput(ndarray)" =+     '[ '("grad_scale", AttrOpt Float),+        '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool),+        '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool),+        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),+        '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle),+        '("label", AttrOpt NDArrayHandle)]++_SoftmaxOutput ::+               forall args . Fullfilled "_SoftmaxOutput(ndarray)" args =>+                 ArgsHMap "_SoftmaxOutput(ndarray)" args -> IO [NDArrayHandle]+_SoftmaxOutput args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float),+               ("ignore_label",) . showValue <$>+                 (args !? #ignore_label :: Maybe Float),+               ("multi_output",) . showValue <$>+                 (args !? #multi_output :: Maybe Bool),+               ("use_ignore",) . showValue <$>+                 (args !? #use_ignore :: Maybe Bool),+               ("preserve_shape",) . showValue <$>+                 (args !? #preserve_shape :: Maybe Bool),+               ("normalization",) . showValue <$>+                 (args !? #normalization ::+                    Maybe (EnumType '["batch", "null", "valid"])),+               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),+               ("smooth_alpha",) . showValue <$>+                 (args !? #smooth_alpha :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SoftmaxOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_SoftmaxOutput_upd ::+                   forall args . Fullfilled "_SoftmaxOutput(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_SoftmaxOutput(ndarray)" args -> IO ()+_SoftmaxOutput_upd outputs args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float),+               ("ignore_label",) . showValue <$>+                 (args !? #ignore_label :: Maybe Float),+               ("multi_output",) . showValue <$>+                 (args !? #multi_output :: Maybe Bool),+               ("use_ignore",) . showValue <$>+                 (args !? #use_ignore :: Maybe Bool),+               ("preserve_shape",) . showValue <$>+                 (args !? #preserve_shape :: Maybe Bool),+               ("normalization",) . showValue <$>+                 (args !? #normalization ::+                    Maybe (EnumType '["batch", "null", "valid"])),+               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),+               ("smooth_alpha",) . showValue <$>+                 (args !? #smooth_alpha :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SoftmaxOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SoftmaxOutput(ndarray)" =+     '[]++_backward_SoftmaxOutput ::+                        forall args . Fullfilled "_backward_SoftmaxOutput(ndarray)" args =>+                          ArgsHMap "_backward_SoftmaxOutput(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_SoftmaxOutput args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SoftmaxOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SoftmaxOutput_upd ::+                            forall args . Fullfilled "_backward_SoftmaxOutput(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_SoftmaxOutput(ndarray)" args -> IO ()+_backward_SoftmaxOutput_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SoftmaxOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Softmax(ndarray)" =+     '[ '("grad_scale", AttrOpt Float),+        '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool),+        '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool),+        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),+        '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle)]++_Softmax ::+         forall args . Fullfilled "_Softmax(ndarray)" args =>+           ArgsHMap "_Softmax(ndarray)" args -> IO [NDArrayHandle]+_Softmax args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float),+               ("ignore_label",) . showValue <$>+                 (args !? #ignore_label :: Maybe Float),+               ("multi_output",) . showValue <$>+                 (args !? #multi_output :: Maybe Bool),+               ("use_ignore",) . showValue <$>+                 (args !? #use_ignore :: Maybe Bool),+               ("preserve_shape",) . showValue <$>+                 (args !? #preserve_shape :: Maybe Bool),+               ("normalization",) . showValue <$>+                 (args !? #normalization ::+                    Maybe (EnumType '["batch", "null", "valid"])),+               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),+               ("smooth_alpha",) . showValue <$>+                 (args !? #smooth_alpha :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Softmax_upd ::+             forall args . Fullfilled "_Softmax(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "_Softmax(ndarray)" args -> IO ()+_Softmax_upd outputs args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float),+               ("ignore_label",) . showValue <$>+                 (args !? #ignore_label :: Maybe Float),+               ("multi_output",) . showValue <$>+                 (args !? #multi_output :: Maybe Bool),+               ("use_ignore",) . showValue <$>+                 (args !? #use_ignore :: Maybe Bool),+               ("preserve_shape",) . showValue <$>+                 (args !? #preserve_shape :: Maybe Bool),+               ("normalization",) . showValue <$>+                 (args !? #normalization ::+                    Maybe (EnumType '["batch", "null", "valid"])),+               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),+               ("smooth_alpha",) . showValue <$>+                 (args !? #smooth_alpha :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Softmax(ndarray)" = '[]++_backward_Softmax ::+                  forall args . Fullfilled "_backward_Softmax(ndarray)" args =>+                    ArgsHMap "_backward_Softmax(ndarray)" args -> IO [NDArrayHandle]+_backward_Softmax args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Softmax_upd ::+                      forall args . Fullfilled "_backward_Softmax(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_Softmax(ndarray)" args -> IO ()+_backward_Softmax_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_BilinearSampler(ndarray)" =+     '[ '("cudnn_off", AttrOpt (Maybe Bool)),+        '("data", AttrOpt NDArrayHandle), '("grid", AttrOpt NDArrayHandle)]++_BilinearSampler ::+                 forall args . Fullfilled "_BilinearSampler(ndarray)" args =>+                   ArgsHMap "_BilinearSampler(ndarray)" args -> IO [NDArrayHandle]+_BilinearSampler args+  = let scalarArgs+          = catMaybes+              [("cudnn_off",) . showValue <$>+                 (args !? #cudnn_off :: Maybe (Maybe Bool))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("grid",) <$> (args !? #grid :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BilinearSampler"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_BilinearSampler_upd ::+                     forall args . Fullfilled "_BilinearSampler(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_BilinearSampler(ndarray)" args -> IO ()+_BilinearSampler_upd outputs args+  = let scalarArgs+          = catMaybes+              [("cudnn_off",) . showValue <$>+                 (args !? #cudnn_off :: Maybe (Maybe Bool))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("grid",) <$> (args !? #grid :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BilinearSampler"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_BilinearSampler(ndarray)" =+     '[]++_backward_BilinearSampler ::+                          forall args .+                            Fullfilled "_backward_BilinearSampler(ndarray)" args =>+                            ArgsHMap "_backward_BilinearSampler(ndarray)" args ->+                              IO [NDArrayHandle]+_backward_BilinearSampler args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BilinearSampler"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_BilinearSampler_upd ::+                              forall args .+                                Fullfilled "_backward_BilinearSampler(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_backward_BilinearSampler(ndarray)" args -> IO ()+_backward_BilinearSampler_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BilinearSampler"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_LeakyReLU(ndarray)" = '[]++_backward_LeakyReLU ::+                    forall args . Fullfilled "_backward_LeakyReLU(ndarray)" args =>+                      ArgsHMap "_backward_LeakyReLU(ndarray)" args -> IO [NDArrayHandle]+_backward_LeakyReLU args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LeakyReLU"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_LeakyReLU_upd ::+                        forall args . Fullfilled "_backward_LeakyReLU(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_backward_LeakyReLU(ndarray)" args -> IO ()+_backward_LeakyReLU_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LeakyReLU"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Crop(ndarray)" =+     '[ '("num_args", AttrReq Int), '("offset", AttrOpt [Int]),+        '("h_w", AttrOpt [Int]), '("center_crop", AttrOpt Bool),+        '("data", AttrOpt [NDArrayHandle])]++_Crop ::+      forall args . Fullfilled "_Crop(ndarray)" args =>+        ArgsHMap "_Crop(ndarray)" args -> IO [NDArrayHandle]+_Crop args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]),+               ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]),+               ("center_crop",) . showValue <$>+                 (args !? #center_crop :: Maybe Bool)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "Crop"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        Nothing+         return listndarr++_Crop_upd ::+          forall args . Fullfilled "_Crop(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "_Crop(ndarray)" args -> IO ()+_Crop_upd outputs args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]),+               ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]),+               ("center_crop",) . showValue <$>+                 (args !? #center_crop :: Maybe Bool)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "Crop"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Crop(ndarray)" = '[]++_backward_Crop ::+               forall args . Fullfilled "_backward_Crop(ndarray)" args =>+                 ArgsHMap "_backward_Crop(ndarray)" args -> IO [NDArrayHandle]+_backward_Crop args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Crop"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Crop_upd ::+                   forall args . Fullfilled "_backward_Crop(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_Crop(ndarray)" args -> IO ()+_backward_Crop_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Crop"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_ROIPooling(ndarray)" =+     '[ '("pooled_size", AttrReq [Int]),+        '("spatial_scale", AttrReq Float),+        '("data", AttrOpt NDArrayHandle), '("rois", AttrOpt NDArrayHandle)]++_ROIPooling ::+            forall args . Fullfilled "_ROIPooling(ndarray)" args =>+              ArgsHMap "_ROIPooling(ndarray)" args -> IO [NDArrayHandle]+_ROIPooling args+  = let scalarArgs+          = catMaybes+              [("pooled_size",) . showValue <$>+                 (args !? #pooled_size :: Maybe [Int]),+               ("spatial_scale",) . showValue <$>+                 (args !? #spatial_scale :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ROIPooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_ROIPooling_upd ::+                forall args . Fullfilled "_ROIPooling(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_ROIPooling(ndarray)" args -> IO ()+_ROIPooling_upd outputs args+  = let scalarArgs+          = catMaybes+              [("pooled_size",) . showValue <$>+                 (args !? #pooled_size :: Maybe [Int]),+               ("spatial_scale",) . showValue <$>+                 (args !? #spatial_scale :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ROIPooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_ROIPooling(ndarray)" = '[]++_backward_ROIPooling ::+                     forall args . Fullfilled "_backward_ROIPooling(ndarray)" args =>+                       ArgsHMap "_backward_ROIPooling(ndarray)" args -> IO [NDArrayHandle]+_backward_ROIPooling args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_ROIPooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_ROIPooling_upd ::+                         forall args . Fullfilled "_backward_ROIPooling(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_ROIPooling(ndarray)" args -> IO ()+_backward_ROIPooling_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_ROIPooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_SequenceLast(ndarray)" =+     '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int),+        '("data", AttrOpt NDArrayHandle),+        '("sequence_length", AttrOpt NDArrayHandle)]++_SequenceLast ::+              forall args . Fullfilled "_SequenceLast(ndarray)" args =>+                ArgsHMap "_SequenceLast(ndarray)" args -> IO [NDArrayHandle]+_SequenceLast args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceLast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_SequenceLast_upd ::+                  forall args . Fullfilled "_SequenceLast(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_SequenceLast(ndarray)" args -> IO ()+_SequenceLast_upd outputs args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceLast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SequenceLast(ndarray)" = '[]++_backward_SequenceLast ::+                       forall args . Fullfilled "_backward_SequenceLast(ndarray)" args =>+                         ArgsHMap "_backward_SequenceLast(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_SequenceLast args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceLast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SequenceLast_upd ::+                           forall args . Fullfilled "_backward_SequenceLast(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_SequenceLast(ndarray)" args -> IO ()+_backward_SequenceLast_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceLast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_CrossDeviceCopy(ndarray)" = '[]++_CrossDeviceCopy ::+                 forall args . Fullfilled "_CrossDeviceCopy(ndarray)" args =>+                   ArgsHMap "_CrossDeviceCopy(ndarray)" args -> IO [NDArrayHandle]+_CrossDeviceCopy args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_CrossDeviceCopy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_CrossDeviceCopy_upd ::+                     forall args . Fullfilled "_CrossDeviceCopy(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_CrossDeviceCopy(ndarray)" args -> IO ()+_CrossDeviceCopy_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_CrossDeviceCopy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward__CrossDeviceCopy(ndarray)" =+     '[]++_backward__CrossDeviceCopy ::+                           forall args .+                             Fullfilled "_backward__CrossDeviceCopy(ndarray)" args =>+                             ArgsHMap "_backward__CrossDeviceCopy(ndarray)" args ->+                               IO [NDArrayHandle]+_backward__CrossDeviceCopy args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__CrossDeviceCopy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__CrossDeviceCopy_upd ::+                               forall args .+                                 Fullfilled "_backward__CrossDeviceCopy(ndarray)" args =>+                                 [NDArrayHandle] ->+                                   ArgsHMap "_backward__CrossDeviceCopy(ndarray)" args -> IO ()+_backward__CrossDeviceCopy_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__CrossDeviceCopy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_SpatialTransformer(ndarray)" =+     '[ '("target_shape", AttrOpt [Int]),+        '("transform_type", AttrReq (EnumType '["affine"])),+        '("sampler_type", AttrReq (EnumType '["bilinear"])),+        '("cudnn_off", AttrOpt (Maybe Bool)),+        '("data", AttrOpt NDArrayHandle), '("loc", AttrOpt NDArrayHandle)]++_SpatialTransformer ::+                    forall args . Fullfilled "_SpatialTransformer(ndarray)" args =>+                      ArgsHMap "_SpatialTransformer(ndarray)" args -> IO [NDArrayHandle]+_SpatialTransformer args+  = let scalarArgs+          = catMaybes+              [("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("transform_type",) . showValue <$>+                 (args !? #transform_type :: Maybe (EnumType '["affine"])),+               ("sampler_type",) . showValue <$>+                 (args !? #sampler_type :: Maybe (EnumType '["bilinear"])),+               ("cudnn_off",) . showValue <$>+                 (args !? #cudnn_off :: Maybe (Maybe Bool))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("loc",) <$> (args !? #loc :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SpatialTransformer"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_SpatialTransformer_upd ::+                        forall args . Fullfilled "_SpatialTransformer(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_SpatialTransformer(ndarray)" args -> IO ()+_SpatialTransformer_upd outputs args+  = let scalarArgs+          = catMaybes+              [("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("transform_type",) . showValue <$>+                 (args !? #transform_type :: Maybe (EnumType '["affine"])),+               ("sampler_type",) . showValue <$>+                 (args !? #sampler_type :: Maybe (EnumType '["bilinear"])),+               ("cudnn_off",) . showValue <$>+                 (args !? #cudnn_off :: Maybe (Maybe Bool))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("loc",) <$> (args !? #loc :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SpatialTransformer"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SpatialTransformer(ndarray)"+     = '[]++_backward_SpatialTransformer ::+                             forall args .+                               Fullfilled "_backward_SpatialTransformer(ndarray)" args =>+                               ArgsHMap "_backward_SpatialTransformer(ndarray)" args ->+                                 IO [NDArrayHandle]+_backward_SpatialTransformer args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SpatialTransformer"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SpatialTransformer_upd ::+                                 forall args .+                                   Fullfilled "_backward_SpatialTransformer(ndarray)" args =>+                                   [NDArrayHandle] ->+                                     ArgsHMap "_backward_SpatialTransformer(ndarray)" args -> IO ()+_backward_SpatialTransformer_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SpatialTransformer"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SwapAxis(ndarray)" = '[]++_backward_SwapAxis ::+                   forall args . Fullfilled "_backward_SwapAxis(ndarray)" args =>+                     ArgsHMap "_backward_SwapAxis(ndarray)" args -> IO [NDArrayHandle]+_backward_SwapAxis args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SwapAxis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SwapAxis_upd ::+                       forall args . Fullfilled "_backward_SwapAxis(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_backward_SwapAxis(ndarray)" args -> IO ()+_backward_SwapAxis_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SwapAxis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_L2Normalization(ndarray)" =+     '[ '("eps", AttrOpt Float),+        '("mode", AttrOpt (EnumType '["channel", "instance", "spatial"])),+        '("data", AttrOpt NDArrayHandle)]++_L2Normalization ::+                 forall args . Fullfilled "_L2Normalization(ndarray)" args =>+                   ArgsHMap "_L2Normalization(ndarray)" args -> IO [NDArrayHandle]+_L2Normalization args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["channel", "instance", "spatial"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "L2Normalization"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_L2Normalization_upd ::+                     forall args . Fullfilled "_L2Normalization(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_L2Normalization(ndarray)" args -> IO ()+_L2Normalization_upd outputs args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["channel", "instance", "spatial"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "L2Normalization"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_L2Normalization(ndarray)" =+     '[]++_backward_L2Normalization ::+                          forall args .+                            Fullfilled "_backward_L2Normalization(ndarray)" args =>+                            ArgsHMap "_backward_L2Normalization(ndarray)" args ->+                              IO [NDArrayHandle]+_backward_L2Normalization args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_L2Normalization"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_L2Normalization_upd ::+                              forall args .+                                Fullfilled "_backward_L2Normalization(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_backward_L2Normalization(ndarray)" args -> IO ()+_backward_L2Normalization_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_L2Normalization"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Correlation(ndarray)" =+     '[ '("kernel_size", AttrOpt Int),+        '("max_displacement", AttrOpt Int), '("stride1", AttrOpt Int),+        '("stride2", AttrOpt Int), '("pad_size", AttrOpt Int),+        '("is_multiply", AttrOpt Bool), '("data1", AttrOpt NDArrayHandle),+        '("data2", AttrOpt NDArrayHandle)]++_Correlation ::+             forall args . Fullfilled "_Correlation(ndarray)" args =>+               ArgsHMap "_Correlation(ndarray)" args -> IO [NDArrayHandle]+_Correlation args+  = let scalarArgs+          = catMaybes+              [("kernel_size",) . showValue <$>+                 (args !? #kernel_size :: Maybe Int),+               ("max_displacement",) . showValue <$>+                 (args !? #max_displacement :: Maybe Int),+               ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int),+               ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int),+               ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int),+               ("is_multiply",) . showValue <$>+                 (args !? #is_multiply :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data1",) <$> (args !? #data1 :: Maybe NDArrayHandle),+               ("data2",) <$> (args !? #data2 :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Correlation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Correlation_upd ::+                 forall args . Fullfilled "_Correlation(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_Correlation(ndarray)" args -> IO ()+_Correlation_upd outputs args+  = let scalarArgs+          = catMaybes+              [("kernel_size",) . showValue <$>+                 (args !? #kernel_size :: Maybe Int),+               ("max_displacement",) . showValue <$>+                 (args !? #max_displacement :: Maybe Int),+               ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int),+               ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int),+               ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int),+               ("is_multiply",) . showValue <$>+                 (args !? #is_multiply :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data1",) <$> (args !? #data1 :: Maybe NDArrayHandle),+               ("data2",) <$> (args !? #data2 :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Correlation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Correlation(ndarray)" = '[]++_backward_Correlation ::+                      forall args . Fullfilled "_backward_Correlation(ndarray)" args =>+                        ArgsHMap "_backward_Correlation(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_Correlation args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Correlation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Correlation_upd ::+                          forall args . Fullfilled "_backward_Correlation(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_Correlation(ndarray)" args -> IO ()+_backward_Correlation_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Correlation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward_IdentityAttachKLSparseReg(ndarray)" = '[]++_backward_IdentityAttachKLSparseReg ::+                                    forall args .+                                      Fullfilled "_backward_IdentityAttachKLSparseReg(ndarray)"+                                        args =>+                                      ArgsHMap "_backward_IdentityAttachKLSparseReg(ndarray)" args+                                        -> IO [NDArrayHandle]+_backward_IdentityAttachKLSparseReg args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_IdentityAttachKLSparseReg_upd ::+                                        forall args .+                                          Fullfilled "_backward_IdentityAttachKLSparseReg(ndarray)"+                                            args =>+                                          [NDArrayHandle] ->+                                            ArgsHMap "_backward_IdentityAttachKLSparseReg(ndarray)"+                                              args+                                              -> IO ()+_backward_IdentityAttachKLSparseReg_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_MakeLoss(ndarray)" =+     '[ '("grad_scale", AttrOpt Float),+        '("valid_thresh", AttrOpt Float),+        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),+        '("data", AttrOpt NDArrayHandle)]++_MakeLoss ::+          forall args . Fullfilled "_MakeLoss(ndarray)" args =>+            ArgsHMap "_MakeLoss(ndarray)" args -> IO [NDArrayHandle]+_MakeLoss args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float),+               ("valid_thresh",) . showValue <$>+                 (args !? #valid_thresh :: Maybe Float),+               ("normalization",) . showValue <$>+                 (args !? #normalization ::+                    Maybe (EnumType '["batch", "null", "valid"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "MakeLoss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_MakeLoss_upd ::+              forall args . Fullfilled "_MakeLoss(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "_MakeLoss(ndarray)" args -> IO ()+_MakeLoss_upd outputs args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float),+               ("valid_thresh",) . showValue <$>+                 (args !? #valid_thresh :: Maybe Float),+               ("normalization",) . showValue <$>+                 (args !? #normalization ::+                    Maybe (EnumType '["batch", "null", "valid"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "MakeLoss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_MakeLoss(ndarray)" = '[]++_backward_MakeLoss ::+                   forall args . Fullfilled "_backward_MakeLoss(ndarray)" args =>+                     ArgsHMap "_backward_MakeLoss(ndarray)" args -> IO [NDArrayHandle]+_backward_MakeLoss args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_MakeLoss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_MakeLoss_upd ::+                       forall args . Fullfilled "_backward_MakeLoss(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_backward_MakeLoss(ndarray)" args -> IO ()+_backward_MakeLoss_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_MakeLoss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SliceChannel(ndarray)" = '[]++_backward_SliceChannel ::+                       forall args . Fullfilled "_backward_SliceChannel(ndarray)" args =>+                         ArgsHMap "_backward_SliceChannel(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_SliceChannel args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SliceChannel"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SliceChannel_upd ::+                           forall args . Fullfilled "_backward_SliceChannel(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_SliceChannel(ndarray)" args -> IO ()+_backward_SliceChannel_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SliceChannel"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_RNN(ndarray)" =+     '[ '("state_size", AttrReq Int), '("num_layers", AttrReq Int),+        '("bidirectional", AttrOpt Bool),+        '("mode",+          AttrReq (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),+        '("p", AttrOpt Float), '("state_outputs", AttrOpt Bool),+        '("projection_size", AttrOpt (Maybe Int)),+        '("lstm_state_clip_min", AttrOpt (Maybe Double)),+        '("lstm_state_clip_max", AttrOpt (Maybe Double)),+        '("lstm_state_clip_nan", AttrOpt Bool),+        '("data", AttrOpt NDArrayHandle),+        '("parameters", AttrOpt NDArrayHandle),+        '("state", AttrOpt NDArrayHandle),+        '("state_cell", AttrOpt NDArrayHandle)]++_RNN ::+     forall args . Fullfilled "_RNN(ndarray)" args =>+       ArgsHMap "_RNN(ndarray)" args -> IO [NDArrayHandle]+_RNN args+  = let scalarArgs+          = catMaybes+              [("state_size",) . showValue <$>+                 (args !? #state_size :: Maybe Int),+               ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int),+               ("bidirectional",) . showValue <$>+                 (args !? #bidirectional :: Maybe Bool),+               ("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),+               ("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("state_outputs",) . showValue <$>+                 (args !? #state_outputs :: Maybe Bool),+               ("projection_size",) . showValue <$>+                 (args !? #projection_size :: Maybe (Maybe Int)),+               ("lstm_state_clip_min",) . showValue <$>+                 (args !? #lstm_state_clip_min :: Maybe (Maybe Double)),+               ("lstm_state_clip_max",) . showValue <$>+                 (args !? #lstm_state_clip_max :: Maybe (Maybe Double)),+               ("lstm_state_clip_nan",) . showValue <$>+                 (args !? #lstm_state_clip_nan :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("parameters",) <$> (args !? #parameters :: Maybe NDArrayHandle),+               ("state",) <$> (args !? #state :: Maybe NDArrayHandle),+               ("state_cell",) <$> (args !? #state_cell :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "RNN"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_RNN_upd ::+         forall args . Fullfilled "_RNN(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "_RNN(ndarray)" args -> IO ()+_RNN_upd outputs args+  = let scalarArgs+          = catMaybes+              [("state_size",) . showValue <$>+                 (args !? #state_size :: Maybe Int),+               ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int),+               ("bidirectional",) . showValue <$>+                 (args !? #bidirectional :: Maybe Bool),+               ("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),+               ("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("state_outputs",) . showValue <$>+                 (args !? #state_outputs :: Maybe Bool),+               ("projection_size",) . showValue <$>+                 (args !? #projection_size :: Maybe (Maybe Int)),+               ("lstm_state_clip_min",) . showValue <$>+                 (args !? #lstm_state_clip_min :: Maybe (Maybe Double)),+               ("lstm_state_clip_max",) . showValue <$>+                 (args !? #lstm_state_clip_max :: Maybe (Maybe Double)),+               ("lstm_state_clip_nan",) . showValue <$>+                 (args !? #lstm_state_clip_nan :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("parameters",) <$> (args !? #parameters :: Maybe NDArrayHandle),+               ("state",) <$> (args !? #state :: Maybe NDArrayHandle),+               ("state_cell",) <$> (args !? #state_cell :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "RNN"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_RNN(ndarray)" = '[]++_backward_RNN ::+              forall args . Fullfilled "_backward_RNN(ndarray)" args =>+                ArgsHMap "_backward_RNN(ndarray)" args -> IO [NDArrayHandle]+_backward_RNN args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_RNN"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_RNN_upd ::+                  forall args . Fullfilled "_backward_RNN(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_RNN(ndarray)" args -> IO ()+_backward_RNN_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_RNN"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Pooling_v1(ndarray)" =+     '[ '("kernel", AttrOpt [Int]),+        '("pool_type", AttrOpt (EnumType '["avg", "max", "sum"])),+        '("global_pool", AttrOpt Bool),+        '("pooling_convention", AttrOpt (EnumType '["full", "valid"])),+        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("data", AttrOpt NDArrayHandle)]++_Pooling_v1 ::+            forall args . Fullfilled "_Pooling_v1(ndarray)" args =>+              ArgsHMap "_Pooling_v1(ndarray)" args -> IO [NDArrayHandle]+_Pooling_v1 args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("pool_type",) . showValue <$>+                 (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])),+               ("global_pool",) . showValue <$>+                 (args !? #global_pool :: Maybe Bool),+               ("pooling_convention",) . showValue <$>+                 (args !? #pooling_convention ::+                    Maybe (EnumType '["full", "valid"])),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pooling_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Pooling_v1_upd ::+                forall args . Fullfilled "_Pooling_v1(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_Pooling_v1(ndarray)" args -> IO ()+_Pooling_v1_upd outputs args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("pool_type",) . showValue <$>+                 (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])),+               ("global_pool",) . showValue <$>+                 (args !? #global_pool :: Maybe Bool),+               ("pooling_convention",) . showValue <$>+                 (args !? #pooling_convention ::+                    Maybe (EnumType '["full", "valid"])),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pooling_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Pooling_v1(ndarray)" = '[]++_backward_Pooling_v1 ::+                     forall args . Fullfilled "_backward_Pooling_v1(ndarray)" args =>+                       ArgsHMap "_backward_Pooling_v1(ndarray)" args -> IO [NDArrayHandle]+_backward_Pooling_v1 args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pooling_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Pooling_v1_upd ::+                         forall args . Fullfilled "_backward_Pooling_v1(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_Pooling_v1(ndarray)" args -> IO ()+_backward_Pooling_v1_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pooling_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_BatchNorm_v1(ndarray)" = '[]++_backward_BatchNorm_v1 ::+                       forall args . Fullfilled "_backward_BatchNorm_v1(ndarray)" args =>+                         ArgsHMap "_backward_BatchNorm_v1(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_BatchNorm_v1 args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BatchNorm_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_BatchNorm_v1_upd ::+                           forall args . Fullfilled "_backward_BatchNorm_v1(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_BatchNorm_v1(ndarray)" args -> IO ()+_backward_BatchNorm_v1_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BatchNorm_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_SequenceMask(ndarray)" =+     '[ '("use_sequence_length", AttrOpt Bool),+        '("value", AttrOpt Float), '("axis", AttrOpt Int),+        '("data", AttrOpt NDArrayHandle),+        '("sequence_length", AttrOpt NDArrayHandle)]++_SequenceMask ::+              forall args . Fullfilled "_SequenceMask(ndarray)" args =>+                ArgsHMap "_SequenceMask(ndarray)" args -> IO [NDArrayHandle]+_SequenceMask args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool),+               ("value",) . showValue <$> (args !? #value :: Maybe Float),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceMask"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_SequenceMask_upd ::+                  forall args . Fullfilled "_SequenceMask(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_SequenceMask(ndarray)" args -> IO ()+_SequenceMask_upd outputs args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool),+               ("value",) . showValue <$> (args !? #value :: Maybe Float),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceMask"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SequenceMask(ndarray)" = '[]++_backward_SequenceMask ::+                       forall args . Fullfilled "_backward_SequenceMask(ndarray)" args =>+                         ArgsHMap "_backward_SequenceMask(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_SequenceMask args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceMask"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SequenceMask_upd ::+                           forall args . Fullfilled "_backward_SequenceMask(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_SequenceMask(ndarray)" args -> IO ()+_backward_SequenceMask_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceMask"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_set_value(ndarray)" =+     '[ '("src", AttrOpt Float)]++_set_value ::+           forall args . Fullfilled "_set_value(ndarray)" args =>+             ArgsHMap "_set_value(ndarray)" args -> IO [NDArrayHandle]+_set_value args+  = let scalarArgs+          = catMaybes+              [("src",) . showValue <$> (args !? #src :: Maybe Float)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_set_value"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_set_value_upd ::+               forall args . Fullfilled "_set_value(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "_set_value(ndarray)" args -> IO ()+_set_value_upd outputs args+  = let scalarArgs+          = catMaybes+              [("src",) . showValue <$> (args !? #src :: Maybe Float)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_set_value"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_onehot_encode(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_onehot_encode ::+               forall args . Fullfilled "_onehot_encode(ndarray)" args =>+                 ArgsHMap "_onehot_encode(ndarray)" args -> IO [NDArrayHandle]+_onehot_encode args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_onehot_encode"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_onehot_encode_upd ::+                   forall args . Fullfilled "_onehot_encode(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_onehot_encode(ndarray)" args -> IO ()+_onehot_encode_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_onehot_encode"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "choose_element_0index(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++choose_element_0index ::+                      forall args . Fullfilled "choose_element_0index(ndarray)" args =>+                        ArgsHMap "choose_element_0index(ndarray)" args ->+                          IO [NDArrayHandle]+choose_element_0index args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "choose_element_0index"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++choose_element_0index_upd ::+                          forall args . Fullfilled "choose_element_0index(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "choose_element_0index(ndarray)" args -> IO ()+choose_element_0index_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "choose_element_0index"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "fill_element_0index(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("mhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]++fill_element_0index ::+                    forall args . Fullfilled "fill_element_0index(ndarray)" args =>+                      ArgsHMap "fill_element_0index(ndarray)" args -> IO [NDArrayHandle]+fill_element_0index args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("mhs",) <$> (args !? #mhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "fill_element_0index"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++fill_element_0index_upd ::+                        forall args . Fullfilled "fill_element_0index(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "fill_element_0index(ndarray)" args -> IO ()+fill_element_0index_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("mhs",) <$> (args !? #mhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "fill_element_0index"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_imdecode(ndarray)" =+     '[ '("index", AttrOpt Int), '("x0", AttrOpt Int),+        '("y0", AttrOpt Int), '("x1", AttrOpt Int), '("y1", AttrOpt Int),+        '("c", AttrOpt Int), '("size", AttrOpt Int),+        '("mean", AttrOpt NDArrayHandle)]++_imdecode ::+          forall args . Fullfilled "_imdecode(ndarray)" args =>+            ArgsHMap "_imdecode(ndarray)" args -> IO [NDArrayHandle]+_imdecode args+  = let scalarArgs+          = catMaybes+              [("index",) . showValue <$> (args !? #index :: Maybe Int),+               ("x0",) . showValue <$> (args !? #x0 :: Maybe Int),+               ("y0",) . showValue <$> (args !? #y0 :: Maybe Int),+               ("x1",) . showValue <$> (args !? #x1 :: Maybe Int),+               ("y1",) . showValue <$> (args !? #y1 :: Maybe Int),+               ("c",) . showValue <$> (args !? #c :: Maybe Int),+               ("size",) . showValue <$> (args !? #size :: Maybe Int)]+        tensorArgs+          = catMaybes [("mean",) <$> (args !? #mean :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_imdecode"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_imdecode_upd ::+              forall args . Fullfilled "_imdecode(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "_imdecode(ndarray)" args -> IO ()+_imdecode_upd outputs args+  = let scalarArgs+          = catMaybes+              [("index",) . showValue <$> (args !? #index :: Maybe Int),+               ("x0",) . showValue <$> (args !? #x0 :: Maybe Int),+               ("y0",) . showValue <$> (args !? #y0 :: Maybe Int),+               ("x1",) . showValue <$> (args !? #x1 :: Maybe Int),+               ("y1",) . showValue <$> (args !? #y1 :: Maybe Int),+               ("c",) . showValue <$> (args !? #c :: Maybe Int),+               ("size",) . showValue <$> (args !? #size :: Maybe Int)]+        tensorArgs+          = catMaybes [("mean",) <$> (args !? #mean :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_imdecode"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()
+ ops/1.4/MXNet/Base/Operators/Symbol.hs view
@@ -0,0 +1,12038 @@+module MXNet.Base.Operators.Symbol where+import MXNet.Base.Raw+import MXNet.Base.Spec.Operator+import MXNet.Base.Spec.HMap+import Data.Maybe (catMaybes, fromMaybe)++type instance ParameterList "_CuDNNBatchNorm(symbol)" =+     '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float),+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),+        '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int),+        '("cudnn_off", AttrOpt Bool), '("data", AttrOpt SymbolHandle),+        '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle),+        '("moving_mean", AttrOpt SymbolHandle),+        '("moving_var", AttrOpt SymbolHandle)]++_CuDNNBatchNorm ::+                forall args . Fullfilled "_CuDNNBatchNorm(symbol)" args =>+                  String ->+                    ArgsHMap "_CuDNNBatchNorm(symbol)" args -> IO SymbolHandle+_CuDNNBatchNorm name args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),+               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle),+               ("moving_mean",) <$> (args !? #moving_mean :: Maybe SymbolHandle),+               ("moving_var",) <$> (args !? #moving_var :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "CuDNNBatchNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_CuDNNBatchNorm(symbol)" =+     '[]++_backward_CuDNNBatchNorm ::+                         forall args . Fullfilled "_backward_CuDNNBatchNorm(symbol)" args =>+                           String ->+                             ArgsHMap "_backward_CuDNNBatchNorm(symbol)" args -> IO SymbolHandle+_backward_CuDNNBatchNorm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_CuDNNBatchNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_multinomial(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("get_prob", AttrOpt Bool),+        '("dtype",+          AttrOpt+            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),+        '("data", AttrOpt SymbolHandle)]++_sample_multinomial ::+                    forall args . Fullfilled "_sample_multinomial(symbol)" args =>+                      String ->+                        ArgsHMap "_sample_multinomial(symbol)" args -> IO SymbolHandle+_sample_multinomial name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_multinomial"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sample_multinomial(symbol)"+     = '[]++_backward_sample_multinomial ::+                             forall args .+                               Fullfilled "_backward_sample_multinomial(symbol)" args =>+                               String ->+                                 ArgsHMap "_backward_sample_multinomial(symbol)" args ->+                                   IO SymbolHandle+_backward_sample_multinomial name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sample_multinomial"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_uniform(symbol)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("low", AttrOpt SymbolHandle), '("high", AttrOpt SymbolHandle)]++_sample_uniform ::+                forall args . Fullfilled "_sample_uniform(symbol)" args =>+                  String ->+                    ArgsHMap "_sample_uniform(symbol)" args -> IO SymbolHandle+_sample_uniform name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("low",) <$> (args !? #low :: Maybe SymbolHandle),+               ("high",) <$> (args !? #high :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_uniform"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_normal(symbol)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("mu", AttrOpt SymbolHandle), '("sigma", AttrOpt SymbolHandle)]++_sample_normal ::+               forall args . Fullfilled "_sample_normal(symbol)" args =>+                 String -> ArgsHMap "_sample_normal(symbol)" args -> IO SymbolHandle+_sample_normal name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("mu",) <$> (args !? #mu :: Maybe SymbolHandle),+               ("sigma",) <$> (args !? #sigma :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_normal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_gamma(symbol)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("alpha", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle)]++_sample_gamma ::+              forall args . Fullfilled "_sample_gamma(symbol)" args =>+                String -> ArgsHMap "_sample_gamma(symbol)" args -> IO SymbolHandle+_sample_gamma name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("alpha",) <$> (args !? #alpha :: Maybe SymbolHandle),+               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_gamma"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_exponential(symbol)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("lam", AttrOpt SymbolHandle)]++_sample_exponential ::+                    forall args . Fullfilled "_sample_exponential(symbol)" args =>+                      String ->+                        ArgsHMap "_sample_exponential(symbol)" args -> IO SymbolHandle+_sample_exponential name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("lam",) <$> (args !? #lam :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_exponential"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_poisson(symbol)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("lam", AttrOpt SymbolHandle)]++_sample_poisson ::+                forall args . Fullfilled "_sample_poisson(symbol)" args =>+                  String ->+                    ArgsHMap "_sample_poisson(symbol)" args -> IO SymbolHandle+_sample_poisson name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("lam",) <$> (args !? #lam :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_poisson"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_negative_binomial(symbol)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("k", AttrOpt SymbolHandle), '("p", AttrOpt SymbolHandle)]++_sample_negative_binomial ::+                          forall args .+                            Fullfilled "_sample_negative_binomial(symbol)" args =>+                            String ->+                              ArgsHMap "_sample_negative_binomial(symbol)" args ->+                                IO SymbolHandle+_sample_negative_binomial name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("k",) <$> (args !? #k :: Maybe SymbolHandle),+               ("p",) <$> (args !? #p :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_negative_binomial"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_sample_generalized_negative_binomial(symbol)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("mu", AttrOpt SymbolHandle), '("alpha", AttrOpt SymbolHandle)]++_sample_generalized_negative_binomial ::+                                      forall args .+                                        Fullfilled "_sample_generalized_negative_binomial(symbol)"+                                          args =>+                                        String ->+                                          ArgsHMap "_sample_generalized_negative_binomial(symbol)"+                                            args+                                            -> IO SymbolHandle+_sample_generalized_negative_binomial name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("mu",) <$> (args !? #mu :: Maybe SymbolHandle),+               ("alpha",) <$> (args !? #alpha :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_generalized_negative_binomial"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_unique_zipfian(symbol)" =+     '[ '("range_max", AttrReq Int), '("shape", AttrOpt [Int])]++_sample_unique_zipfian ::+                       forall args . Fullfilled "_sample_unique_zipfian(symbol)" args =>+                         String ->+                           ArgsHMap "_sample_unique_zipfian(symbol)" args -> IO SymbolHandle+_sample_unique_zipfian name args+  = let scalarArgs+          = catMaybes+              [("range_max",) . showValue <$> (args !? #range_max :: Maybe Int),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_unique_zipfian"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_uniform(symbol)" =+     '[ '("low", AttrOpt Float), '("high", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_uniform ::+                forall args . Fullfilled "_random_uniform(symbol)" args =>+                  String ->+                    ArgsHMap "_random_uniform(symbol)" args -> IO SymbolHandle+_random_uniform name args+  = let scalarArgs+          = catMaybes+              [("low",) . showValue <$> (args !? #low :: Maybe Float),+               ("high",) . showValue <$> (args !? #high :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_uniform"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_normal(symbol)" =+     '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_normal ::+               forall args . Fullfilled "_random_normal(symbol)" args =>+                 String -> ArgsHMap "_random_normal(symbol)" args -> IO SymbolHandle+_random_normal name args+  = let scalarArgs+          = catMaybes+              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),+               ("scale",) . showValue <$> (args !? #scale :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_normal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_gamma(symbol)" =+     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_gamma ::+              forall args . Fullfilled "_random_gamma(symbol)" args =>+                String -> ArgsHMap "_random_gamma(symbol)" args -> IO SymbolHandle+_random_gamma name args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_gamma"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_exponential(symbol)" =+     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),+        '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_exponential ::+                    forall args . Fullfilled "_random_exponential(symbol)" args =>+                      String ->+                        ArgsHMap "_random_exponential(symbol)" args -> IO SymbolHandle+_random_exponential name args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_exponential"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_poisson(symbol)" =+     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),+        '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_poisson ::+                forall args . Fullfilled "_random_poisson(symbol)" args =>+                  String ->+                    ArgsHMap "_random_poisson(symbol)" args -> IO SymbolHandle+_random_poisson name args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_poisson"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_negative_binomial(symbol)" =+     '[ '("k", AttrOpt Int), '("p", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_negative_binomial ::+                          forall args .+                            Fullfilled "_random_negative_binomial(symbol)" args =>+                            String ->+                              ArgsHMap "_random_negative_binomial(symbol)" args ->+                                IO SymbolHandle+_random_negative_binomial name args+  = let scalarArgs+          = catMaybes+              [("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_negative_binomial"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_random_generalized_negative_binomial(symbol)" =+     '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_generalized_negative_binomial ::+                                      forall args .+                                        Fullfilled "_random_generalized_negative_binomial(symbol)"+                                          args =>+                                        String ->+                                          ArgsHMap "_random_generalized_negative_binomial(symbol)"+                                            args+                                            -> IO SymbolHandle+_random_generalized_negative_binomial name args+  = let scalarArgs+          = catMaybes+              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_generalized_negative_binomial"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_randint(symbol)" =+     '[ '("low", AttrReq Int), '("high", AttrReq Int),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype", AttrOpt (EnumType '["None", "int32", "int64"]))]++_random_randint ::+                forall args . Fullfilled "_random_randint(symbol)" args =>+                  String ->+                    ArgsHMap "_random_randint(symbol)" args -> IO SymbolHandle+_random_randint name args+  = let scalarArgs+          = catMaybes+              [("low",) . showValue <$> (args !? #low :: Maybe Int),+               ("high",) . showValue <$> (args !? #high :: Maybe Int),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype :: Maybe (EnumType '["None", "int32", "int64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_randint"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_uniform_like(symbol)" =+     '[ '("low", AttrOpt Float), '("high", AttrOpt Float),+        '("data", AttrOpt SymbolHandle)]++_random_uniform_like ::+                     forall args . Fullfilled "_random_uniform_like(symbol)" args =>+                       String ->+                         ArgsHMap "_random_uniform_like(symbol)" args -> IO SymbolHandle+_random_uniform_like name args+  = let scalarArgs+          = catMaybes+              [("low",) . showValue <$> (args !? #low :: Maybe Float),+               ("high",) . showValue <$> (args !? #high :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_uniform_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_normal_like(symbol)" =+     '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float),+        '("data", AttrOpt SymbolHandle)]++_random_normal_like ::+                    forall args . Fullfilled "_random_normal_like(symbol)" args =>+                      String ->+                        ArgsHMap "_random_normal_like(symbol)" args -> IO SymbolHandle+_random_normal_like name args+  = let scalarArgs+          = catMaybes+              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),+               ("scale",) . showValue <$> (args !? #scale :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_normal_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_gamma_like(symbol)" =+     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),+        '("data", AttrOpt SymbolHandle)]++_random_gamma_like ::+                   forall args . Fullfilled "_random_gamma_like(symbol)" args =>+                     String ->+                       ArgsHMap "_random_gamma_like(symbol)" args -> IO SymbolHandle+_random_gamma_like name args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_gamma_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_exponential_like(symbol)" =+     '[ '("lam", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_random_exponential_like ::+                         forall args . Fullfilled "_random_exponential_like(symbol)" args =>+                           String ->+                             ArgsHMap "_random_exponential_like(symbol)" args -> IO SymbolHandle+_random_exponential_like name args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_exponential_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_poisson_like(symbol)" =+     '[ '("lam", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_random_poisson_like ::+                     forall args . Fullfilled "_random_poisson_like(symbol)" args =>+                       String ->+                         ArgsHMap "_random_poisson_like(symbol)" args -> IO SymbolHandle+_random_poisson_like name args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_poisson_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_random_negative_binomial_like(symbol)" =+     '[ '("k", AttrOpt Int), '("p", AttrOpt Float),+        '("data", AttrOpt SymbolHandle)]++_random_negative_binomial_like ::+                               forall args .+                                 Fullfilled "_random_negative_binomial_like(symbol)" args =>+                                 String ->+                                   ArgsHMap "_random_negative_binomial_like(symbol)" args ->+                                     IO SymbolHandle+_random_negative_binomial_like name args+  = let scalarArgs+          = catMaybes+              [("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("p",) . showValue <$> (args !? #p :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_negative_binomial_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_random_generalized_negative_binomial_like(symbol)"+     =+     '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float),+        '("data", AttrOpt SymbolHandle)]++_random_generalized_negative_binomial_like ::+                                           forall args .+                                             Fullfilled+                                               "_random_generalized_negative_binomial_like(symbol)"+                                               args =>+                                             String ->+                                               ArgsHMap+                                                 "_random_generalized_negative_binomial_like(symbol)"+                                                 args+                                                 -> IO SymbolHandle+_random_generalized_negative_binomial_like name args+  = let scalarArgs+          = catMaybes+              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_generalized_negative_binomial_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_shuffle(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++_shuffle ::+         forall args . Fullfilled "_shuffle(symbol)" args =>+           String -> ArgsHMap "_shuffle(symbol)" args -> IO SymbolHandle+_shuffle name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_shuffle"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Custom(symbol)" =+     '[ '("op_type", AttrOpt String), '("data", AttrOpt [SymbolHandle])]++_Custom ::+        forall args .+          (Fullfilled "_Custom(symbol)" args,+           PopKey (ArgOf "_Custom(symbol)") args "data",+           Dump (PopResult (ArgOf "_Custom(symbol)") args "data")) =>+          String -> ArgsHMap "_Custom(symbol)" args -> IO SymbolHandle+_Custom name args+  = let scalarArgs = dump (pop args #data)+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "Custom"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_backward_Custom(symbol)" = '[]++_backward_Custom ::+                 forall args . Fullfilled "_backward_Custom(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_Custom(symbol)" args -> IO SymbolHandle+_backward_Custom name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Custom"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_power(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_power ::+                forall args . Fullfilled "broadcast_power(symbol)" args =>+                  String ->+                    ArgsHMap "broadcast_power(symbol)" args -> IO SymbolHandle+broadcast_power name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_power"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_power(symbol)" =+     '[]++_backward_broadcast_power ::+                          forall args .+                            Fullfilled "_backward_broadcast_power(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_broadcast_power(symbol)" args ->+                                IO SymbolHandle+_backward_broadcast_power name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_power"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_maximum(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_maximum ::+                  forall args . Fullfilled "broadcast_maximum(symbol)" args =>+                    String ->+                      ArgsHMap "broadcast_maximum(symbol)" args -> IO SymbolHandle+broadcast_maximum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_maximum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_maximum(symbol)" =+     '[]++_backward_broadcast_maximum ::+                            forall args .+                              Fullfilled "_backward_broadcast_maximum(symbol)" args =>+                              String ->+                                ArgsHMap "_backward_broadcast_maximum(symbol)" args ->+                                  IO SymbolHandle+_backward_broadcast_maximum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_maximum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_minimum(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_minimum ::+                  forall args . Fullfilled "broadcast_minimum(symbol)" args =>+                    String ->+                      ArgsHMap "broadcast_minimum(symbol)" args -> IO SymbolHandle+broadcast_minimum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_minimum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_minimum(symbol)" =+     '[]++_backward_broadcast_minimum ::+                            forall args .+                              Fullfilled "_backward_broadcast_minimum(symbol)" args =>+                              String ->+                                ArgsHMap "_backward_broadcast_minimum(symbol)" args ->+                                  IO SymbolHandle+_backward_broadcast_minimum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_minimum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_hypot(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_hypot ::+                forall args . Fullfilled "broadcast_hypot(symbol)" args =>+                  String ->+                    ArgsHMap "broadcast_hypot(symbol)" args -> IO SymbolHandle+broadcast_hypot name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_hypot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_hypot(symbol)" =+     '[]++_backward_broadcast_hypot ::+                          forall args .+                            Fullfilled "_backward_broadcast_hypot(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_broadcast_hypot(symbol)" args ->+                                IO SymbolHandle+_backward_broadcast_hypot name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_hypot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_equal ::+       forall args . Fullfilled "_equal(symbol)" args =>+         String -> ArgsHMap "_equal(symbol)" args -> IO SymbolHandle+_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_not_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_not_equal ::+           forall args . Fullfilled "_not_equal(symbol)" args =>+             String -> ArgsHMap "_not_equal(symbol)" args -> IO SymbolHandle+_not_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_not_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_greater(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_greater ::+         forall args . Fullfilled "_greater(symbol)" args =>+           String -> ArgsHMap "_greater(symbol)" args -> IO SymbolHandle+_greater name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_greater_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_greater_equal ::+               forall args . Fullfilled "_greater_equal(symbol)" args =>+                 String -> ArgsHMap "_greater_equal(symbol)" args -> IO SymbolHandle+_greater_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_lesser(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_lesser ::+        forall args . Fullfilled "_lesser(symbol)" args =>+          String -> ArgsHMap "_lesser(symbol)" args -> IO SymbolHandle+_lesser name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_lesser_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_lesser_equal ::+              forall args . Fullfilled "_lesser_equal(symbol)" args =>+                String -> ArgsHMap "_lesser_equal(symbol)" args -> IO SymbolHandle+_lesser_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_logical_and(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_logical_and ::+             forall args . Fullfilled "_logical_and(symbol)" args =>+               String -> ArgsHMap "_logical_and(symbol)" args -> IO SymbolHandle+_logical_and name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_and"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_logical_or(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_logical_or ::+            forall args . Fullfilled "_logical_or(symbol)" args =>+              String -> ArgsHMap "_logical_or(symbol)" args -> IO SymbolHandle+_logical_or name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_or"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_logical_xor(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_logical_xor ::+             forall args . Fullfilled "_logical_xor(symbol)" args =>+               String -> ArgsHMap "_logical_xor(symbol)" args -> IO SymbolHandle+_logical_xor name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_xor"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_power(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_power ::+       forall args . Fullfilled "_power(symbol)" args =>+         String -> ArgsHMap "_power(symbol)" args -> IO SymbolHandle+_power name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_power"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_power(symbol)" = '[]++_backward_power ::+                forall args . Fullfilled "_backward_power(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_power(symbol)" args -> IO SymbolHandle+_backward_power name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_power"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_maximum(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_maximum ::+         forall args . Fullfilled "_maximum(symbol)" args =>+           String -> ArgsHMap "_maximum(symbol)" args -> IO SymbolHandle+_maximum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_maximum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_maximum(symbol)" = '[]++_backward_maximum ::+                  forall args . Fullfilled "_backward_maximum(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_maximum(symbol)" args -> IO SymbolHandle+_backward_maximum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_maximum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_minimum(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_minimum ::+         forall args . Fullfilled "_minimum(symbol)" args =>+           String -> ArgsHMap "_minimum(symbol)" args -> IO SymbolHandle+_minimum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minimum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_minimum(symbol)" = '[]++_backward_minimum ::+                  forall args . Fullfilled "_backward_minimum(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_minimum(symbol)" args -> IO SymbolHandle+_backward_minimum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_minimum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_hypot(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_hypot ::+       forall args . Fullfilled "_hypot(symbol)" args =>+         String -> ArgsHMap "_hypot(symbol)" args -> IO SymbolHandle+_hypot name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_hypot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_hypot(symbol)" = '[]++_backward_hypot ::+                forall args . Fullfilled "_backward_hypot(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_hypot(symbol)" args -> IO SymbolHandle+_backward_hypot name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_hypot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_square_sum(symbol)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++_square_sum ::+            forall args . Fullfilled "_square_sum(symbol)" args =>+              String -> ArgsHMap "_square_sum(symbol)" args -> IO SymbolHandle+_square_sum name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_square_sum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_square_sum(symbol)" = '[]++_backward_square_sum ::+                     forall args . Fullfilled "_backward_square_sum(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_square_sum(symbol)" args -> IO SymbolHandle+_backward_square_sum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_square_sum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "add_n(symbol)" =+     '[ '("args", AttrOpt [SymbolHandle])]++add_n ::+      forall args . Fullfilled "add_n(symbol)" args =>+        String -> ArgsHMap "add_n(symbol)" args -> IO SymbolHandle+add_n name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "add_n"+         sym <- if hasKey args #num_args then+                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals+                  else+                  mxSymbolCreateAtomicSymbol (fromOpHandle op)+                    ("num_args" : scalarkeys)+                    (showValue (length array) : scalarvals)+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_zeros_without_dtype(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype", AttrOpt Int)]++_zeros_without_dtype ::+                     forall args . Fullfilled "_zeros_without_dtype(symbol)" args =>+                       String ->+                         ArgsHMap "_zeros_without_dtype(symbol)" args -> IO SymbolHandle+_zeros_without_dtype name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$> (args !? #dtype :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_zeros_without_dtype"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_zeros(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"]))]++_zeros ::+       forall args . Fullfilled "_zeros(symbol)" args =>+         String -> ArgsHMap "_zeros(symbol)" args -> IO SymbolHandle+_zeros name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_zeros"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_eye(symbol)" =+     '[ '("_N", AttrReq Int), '("_M", AttrOpt Int), '("k", AttrOpt Int),+        '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"]))]++_eye ::+     forall args . Fullfilled "_eye(symbol)" args =>+       String -> ArgsHMap "_eye(symbol)" args -> IO SymbolHandle+_eye name args+  = let scalarArgs+          = catMaybes+              [("_N",) . showValue <$> (args !? #_N :: Maybe Int),+               ("_M",) . showValue <$> (args !? #_M :: Maybe Int),+               ("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_eye"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_ones(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"]))]++_ones ::+      forall args . Fullfilled "_ones(symbol)" args =>+        String -> ArgsHMap "_ones(symbol)" args -> IO SymbolHandle+_ones name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_ones"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_full(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("value", AttrReq Double)]++_full ::+      forall args . Fullfilled "_full(symbol)" args =>+        String -> ArgsHMap "_full(symbol)" args -> IO SymbolHandle+_full name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"])),+               ("value",) . showValue <$> (args !? #value :: Maybe Double)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_full"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_arange(symbol)" =+     '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)),+        '("step", AttrOpt Double), '("repeat", AttrOpt Int),+        '("infer_range", AttrOpt Bool), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"]))]++_arange ::+        forall args . Fullfilled "_arange(symbol)" args =>+          String -> ArgsHMap "_arange(symbol)" args -> IO SymbolHandle+_arange name args+  = let scalarArgs+          = catMaybes+              [("start",) . showValue <$> (args !? #start :: Maybe Double),+               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),+               ("step",) . showValue <$> (args !? #step :: Maybe Double),+               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),+               ("infer_range",) . showValue <$>+                 (args !? #infer_range :: Maybe Bool),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_arange"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "zeros_like(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++zeros_like ::+           forall args . Fullfilled "zeros_like(symbol)" args =>+             String -> ArgsHMap "zeros_like(symbol)" args -> IO SymbolHandle+zeros_like name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "zeros_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "ones_like(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++ones_like ::+          forall args . Fullfilled "ones_like(symbol)" args =>+            String -> ArgsHMap "ones_like(symbol)" args -> IO SymbolHandle+ones_like name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ones_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_add(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_add ::+              forall args . Fullfilled "broadcast_add(symbol)" args =>+                String -> ArgsHMap "broadcast_add(symbol)" args -> IO SymbolHandle+broadcast_add name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_add"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_add(symbol)" = '[]++_backward_broadcast_add ::+                        forall args . Fullfilled "_backward_broadcast_add(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_broadcast_add(symbol)" args -> IO SymbolHandle+_backward_broadcast_add name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_add"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_sub(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_sub ::+              forall args . Fullfilled "broadcast_sub(symbol)" args =>+                String -> ArgsHMap "broadcast_sub(symbol)" args -> IO SymbolHandle+broadcast_sub name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_sub"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_sub(symbol)" = '[]++_backward_broadcast_sub ::+                        forall args . Fullfilled "_backward_broadcast_sub(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_broadcast_sub(symbol)" args -> IO SymbolHandle+_backward_broadcast_sub name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_sub"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_mul(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_mul ::+              forall args . Fullfilled "broadcast_mul(symbol)" args =>+                String -> ArgsHMap "broadcast_mul(symbol)" args -> IO SymbolHandle+broadcast_mul name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_mul"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_mul(symbol)" = '[]++_backward_broadcast_mul ::+                        forall args . Fullfilled "_backward_broadcast_mul(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_broadcast_mul(symbol)" args -> IO SymbolHandle+_backward_broadcast_mul name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_mul"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_div(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_div ::+              forall args . Fullfilled "broadcast_div(symbol)" args =>+                String -> ArgsHMap "broadcast_div(symbol)" args -> IO SymbolHandle+broadcast_div name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_div"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_div(symbol)" = '[]++_backward_broadcast_div ::+                        forall args . Fullfilled "_backward_broadcast_div(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_broadcast_div(symbol)" args -> IO SymbolHandle+_backward_broadcast_div name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_div"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_mod(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_mod ::+              forall args . Fullfilled "broadcast_mod(symbol)" args =>+                String -> ArgsHMap "broadcast_mod(symbol)" args -> IO SymbolHandle+broadcast_mod name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_mod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_mod(symbol)" = '[]++_backward_broadcast_mod ::+                        forall args . Fullfilled "_backward_broadcast_mod(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_broadcast_mod(symbol)" args -> IO SymbolHandle+_backward_broadcast_mod name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_mod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_gemm(symbol)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("alpha", AttrOpt Double), '("beta", AttrOpt Double),+        '("axis", AttrOpt Int), '("_A", AttrOpt SymbolHandle),+        '("_B", AttrOpt SymbolHandle), '("_C", AttrOpt SymbolHandle)]++_linalg_gemm ::+             forall args . Fullfilled "_linalg_gemm(symbol)" args =>+               String -> ArgsHMap "_linalg_gemm(symbol)" args -> IO SymbolHandle+_linalg_gemm name args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Double),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),+               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle),+               ("_C",) <$> (args !? #_C :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gemm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_gemm(symbol)" = '[]++_backward_linalg_gemm ::+                      forall args . Fullfilled "_backward_linalg_gemm(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_linalg_gemm(symbol)" args -> IO SymbolHandle+_backward_linalg_gemm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gemm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_gemm2(symbol)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("alpha", AttrOpt Double), '("axis", AttrOpt Int),+        '("_A", AttrOpt SymbolHandle), '("_B", AttrOpt SymbolHandle)]++_linalg_gemm2 ::+              forall args . Fullfilled "_linalg_gemm2(symbol)" args =>+                String -> ArgsHMap "_linalg_gemm2(symbol)" args -> IO SymbolHandle+_linalg_gemm2 name args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),+               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gemm2"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_gemm2(symbol)" = '[]++_backward_linalg_gemm2 ::+                       forall args . Fullfilled "_backward_linalg_gemm2(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_linalg_gemm2(symbol)" args -> IO SymbolHandle+_backward_linalg_gemm2 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gemm2"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_potrf(symbol)" =+     '[ '("_A", AttrOpt SymbolHandle)]++_linalg_potrf ::+              forall args . Fullfilled "_linalg_potrf(symbol)" args =>+                String -> ArgsHMap "_linalg_potrf(symbol)" args -> IO SymbolHandle+_linalg_potrf name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_potrf"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_potrf(symbol)" = '[]++_backward_linalg_potrf ::+                       forall args . Fullfilled "_backward_linalg_potrf(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_linalg_potrf(symbol)" args -> IO SymbolHandle+_backward_linalg_potrf name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_potrf"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_potri(symbol)" =+     '[ '("_A", AttrOpt SymbolHandle)]++_linalg_potri ::+              forall args . Fullfilled "_linalg_potri(symbol)" args =>+                String -> ArgsHMap "_linalg_potri(symbol)" args -> IO SymbolHandle+_linalg_potri name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_potri"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_potri(symbol)" = '[]++_backward_linalg_potri ::+                       forall args . Fullfilled "_backward_linalg_potri(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_linalg_potri(symbol)" args -> IO SymbolHandle+_backward_linalg_potri name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_potri"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_trmm(symbol)" =+     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),+        '("lower", AttrOpt Bool), '("alpha", AttrOpt Double),+        '("_A", AttrOpt SymbolHandle), '("_B", AttrOpt SymbolHandle)]++_linalg_trmm ::+             forall args . Fullfilled "_linalg_trmm(symbol)" args =>+               String -> ArgsHMap "_linalg_trmm(symbol)" args -> IO SymbolHandle+_linalg_trmm name args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),+               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),+               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_trmm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_trmm(symbol)" = '[]++_backward_linalg_trmm ::+                      forall args . Fullfilled "_backward_linalg_trmm(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_linalg_trmm(symbol)" args -> IO SymbolHandle+_backward_linalg_trmm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_trmm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_trsm(symbol)" =+     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),+        '("lower", AttrOpt Bool), '("alpha", AttrOpt Double),+        '("_A", AttrOpt SymbolHandle), '("_B", AttrOpt SymbolHandle)]++_linalg_trsm ::+             forall args . Fullfilled "_linalg_trsm(symbol)" args =>+               String -> ArgsHMap "_linalg_trsm(symbol)" args -> IO SymbolHandle+_linalg_trsm name args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),+               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),+               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_trsm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_trsm(symbol)" = '[]++_backward_linalg_trsm ::+                      forall args . Fullfilled "_backward_linalg_trsm(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_linalg_trsm(symbol)" args -> IO SymbolHandle+_backward_linalg_trsm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_trsm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_sumlogdiag(symbol)" =+     '[ '("_A", AttrOpt SymbolHandle)]++_linalg_sumlogdiag ::+                   forall args . Fullfilled "_linalg_sumlogdiag(symbol)" args =>+                     String ->+                       ArgsHMap "_linalg_sumlogdiag(symbol)" args -> IO SymbolHandle+_linalg_sumlogdiag name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_sumlogdiag"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_sumlogdiag(symbol)" =+     '[]++_backward_linalg_sumlogdiag ::+                            forall args .+                              Fullfilled "_backward_linalg_sumlogdiag(symbol)" args =>+                              String ->+                                ArgsHMap "_backward_linalg_sumlogdiag(symbol)" args ->+                                  IO SymbolHandle+_backward_linalg_sumlogdiag name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_sumlogdiag"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_syrk(symbol)" =+     '[ '("transpose", AttrOpt Bool), '("alpha", AttrOpt Double),+        '("_A", AttrOpt SymbolHandle)]++_linalg_syrk ::+             forall args . Fullfilled "_linalg_syrk(symbol)" args =>+               String -> ArgsHMap "_linalg_syrk(symbol)" args -> IO SymbolHandle+_linalg_syrk name args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_syrk"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_syrk(symbol)" = '[]++_backward_linalg_syrk ::+                      forall args . Fullfilled "_backward_linalg_syrk(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_linalg_syrk(symbol)" args -> IO SymbolHandle+_backward_linalg_syrk name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_syrk"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_gelqf(symbol)" =+     '[ '("_A", AttrOpt SymbolHandle)]++_linalg_gelqf ::+              forall args . Fullfilled "_linalg_gelqf(symbol)" args =>+                String -> ArgsHMap "_linalg_gelqf(symbol)" args -> IO SymbolHandle+_linalg_gelqf name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gelqf"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_gelqf(symbol)" = '[]++_backward_linalg_gelqf ::+                       forall args . Fullfilled "_backward_linalg_gelqf(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_linalg_gelqf(symbol)" args -> IO SymbolHandle+_backward_linalg_gelqf name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gelqf"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_syevd(symbol)" =+     '[ '("_A", AttrOpt SymbolHandle)]++_linalg_syevd ::+              forall args . Fullfilled "_linalg_syevd(symbol)" args =>+                String -> ArgsHMap "_linalg_syevd(symbol)" args -> IO SymbolHandle+_linalg_syevd name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_syevd"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_syevd(symbol)" = '[]++_backward_linalg_syevd ::+                       forall args . Fullfilled "_backward_linalg_syevd(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_linalg_syevd(symbol)" args -> IO SymbolHandle+_backward_linalg_syevd name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_syevd"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_histogram(symbol)" =+     '[ '("bin_cnt", AttrOpt (Maybe Int)), '("range", AttrOpt Int),+        '("data", AttrOpt SymbolHandle), '("bins", AttrOpt SymbolHandle)]++_histogram ::+           forall args . Fullfilled "_histogram(symbol)" args =>+             String -> ArgsHMap "_histogram(symbol)" args -> IO SymbolHandle+_histogram name args+  = let scalarArgs+          = catMaybes+              [("bin_cnt",) . showValue <$>+                 (args !? #bin_cnt :: Maybe (Maybe Int)),+               ("range",) . showValue <$> (args !? #range :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("bins",) <$> (args !? #bins :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_histogram"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "cast_storage(symbol)" =+     '[ '("stype",+          AttrReq (EnumType '["csr", "default", "row_sparse"])),+        '("data", AttrOpt SymbolHandle)]++cast_storage ::+             forall args . Fullfilled "cast_storage(symbol)" args =>+               String -> ArgsHMap "cast_storage(symbol)" args -> IO SymbolHandle+cast_storage name args+  = let scalarArgs+          = catMaybes+              [("stype",) . showValue <$>+                 (args !? #stype ::+                    Maybe (EnumType '["csr", "default", "row_sparse"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cast_storage"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_equal_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_equal_scalar ::+              forall args . Fullfilled "_equal_scalar(symbol)" args =>+                String -> ArgsHMap "_equal_scalar(symbol)" args -> IO SymbolHandle+_equal_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_equal_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_not_equal_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_not_equal_scalar ::+                  forall args . Fullfilled "_not_equal_scalar(symbol)" args =>+                    String ->+                      ArgsHMap "_not_equal_scalar(symbol)" args -> IO SymbolHandle+_not_equal_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_not_equal_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_greater_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_greater_scalar ::+                forall args . Fullfilled "_greater_scalar(symbol)" args =>+                  String ->+                    ArgsHMap "_greater_scalar(symbol)" args -> IO SymbolHandle+_greater_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_greater_equal_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_greater_equal_scalar ::+                      forall args . Fullfilled "_greater_equal_scalar(symbol)" args =>+                        String ->+                          ArgsHMap "_greater_equal_scalar(symbol)" args -> IO SymbolHandle+_greater_equal_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_equal_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_lesser_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_lesser_scalar ::+               forall args . Fullfilled "_lesser_scalar(symbol)" args =>+                 String -> ArgsHMap "_lesser_scalar(symbol)" args -> IO SymbolHandle+_lesser_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_lesser_equal_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_lesser_equal_scalar ::+                     forall args . Fullfilled "_lesser_equal_scalar(symbol)" args =>+                       String ->+                         ArgsHMap "_lesser_equal_scalar(symbol)" args -> IO SymbolHandle+_lesser_equal_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_equal_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_logical_and_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_logical_and_scalar ::+                    forall args . Fullfilled "_logical_and_scalar(symbol)" args =>+                      String ->+                        ArgsHMap "_logical_and_scalar(symbol)" args -> IO SymbolHandle+_logical_and_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_and_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_logical_or_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_logical_or_scalar ::+                   forall args . Fullfilled "_logical_or_scalar(symbol)" args =>+                     String ->+                       ArgsHMap "_logical_or_scalar(symbol)" args -> IO SymbolHandle+_logical_or_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_or_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_logical_xor_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_logical_xor_scalar ::+                    forall args . Fullfilled "_logical_xor_scalar(symbol)" args =>+                      String ->+                        ArgsHMap "_logical_xor_scalar(symbol)" args -> IO SymbolHandle+_logical_xor_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_xor_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "relu(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++relu ::+     forall args . Fullfilled "relu(symbol)" args =>+       String -> ArgsHMap "relu(symbol)" args -> IO SymbolHandle+relu name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "relu"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_relu(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_relu ::+               forall args . Fullfilled "_backward_relu(symbol)" args =>+                 String -> ArgsHMap "_backward_relu(symbol)" args -> IO SymbolHandle+_backward_relu name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_relu"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sigmoid(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++sigmoid ::+        forall args . Fullfilled "sigmoid(symbol)" args =>+          String -> ArgsHMap "sigmoid(symbol)" args -> IO SymbolHandle+sigmoid name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sigmoid"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sigmoid(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_sigmoid ::+                  forall args . Fullfilled "_backward_sigmoid(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_sigmoid(symbol)" args -> IO SymbolHandle+_backward_sigmoid name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sigmoid"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "hard_sigmoid(symbol)" =+     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),+        '("data", AttrOpt SymbolHandle)]++hard_sigmoid ::+             forall args . Fullfilled "hard_sigmoid(symbol)" args =>+               String -> ArgsHMap "hard_sigmoid(symbol)" args -> IO SymbolHandle+hard_sigmoid name args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "hard_sigmoid"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_hard_sigmoid(symbol)" = '[]++_backward_hard_sigmoid ::+                       forall args . Fullfilled "_backward_hard_sigmoid(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_hard_sigmoid(symbol)" args -> IO SymbolHandle+_backward_hard_sigmoid name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_hard_sigmoid"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "softsign(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++softsign ::+         forall args . Fullfilled "softsign(symbol)" args =>+           String -> ArgsHMap "softsign(symbol)" args -> IO SymbolHandle+softsign name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softsign"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_softsign(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_softsign ::+                   forall args . Fullfilled "_backward_softsign(symbol)" args =>+                     String ->+                       ArgsHMap "_backward_softsign(symbol)" args -> IO SymbolHandle+_backward_softsign name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_softsign"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_copy(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++_copy ::+      forall args . Fullfilled "_copy(symbol)" args =>+        String -> ArgsHMap "_copy(symbol)" args -> IO SymbolHandle+_copy name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_copy"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_copy(symbol)" = '[]++_backward_copy ::+               forall args . Fullfilled "_backward_copy(symbol)" args =>+                 String -> ArgsHMap "_backward_copy(symbol)" args -> IO SymbolHandle+_backward_copy name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_copy"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_BlockGrad(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++_BlockGrad ::+           forall args . Fullfilled "_BlockGrad(symbol)" args =>+             String -> ArgsHMap "_BlockGrad(symbol)" args -> IO SymbolHandle+_BlockGrad name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BlockGrad"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "make_loss(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++make_loss ::+          forall args . Fullfilled "make_loss(symbol)" args =>+            String -> ArgsHMap "make_loss(symbol)" args -> IO SymbolHandle+make_loss name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "make_loss"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_identity_with_attr_like_rhs(symbol)"+     =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_identity_with_attr_like_rhs ::+                             forall args .+                               Fullfilled "_identity_with_attr_like_rhs(symbol)" args =>+                               String ->+                                 ArgsHMap "_identity_with_attr_like_rhs(symbol)" args ->+                                   IO SymbolHandle+_identity_with_attr_like_rhs name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_identity_with_attr_like_rhs"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "reshape_like(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++reshape_like ::+             forall args . Fullfilled "reshape_like(symbol)" args =>+               String -> ArgsHMap "reshape_like(symbol)" args -> IO SymbolHandle+reshape_like name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reshape_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "shape_array(symbol)" =+     '[ '("lhs_begin", AttrOpt (Maybe Int)),+        '("lhs_end", AttrOpt (Maybe Int)),+        '("rhs_begin", AttrOpt (Maybe Int)),+        '("rhs_end", AttrOpt (Maybe Int)), '("data", AttrOpt SymbolHandle)]++shape_array ::+            forall args . Fullfilled "shape_array(symbol)" args =>+              String -> ArgsHMap "shape_array(symbol)" args -> IO SymbolHandle+shape_array name args+  = let scalarArgs+          = catMaybes+              [("lhs_begin",) . showValue <$>+                 (args !? #lhs_begin :: Maybe (Maybe Int)),+               ("lhs_end",) . showValue <$>+                 (args !? #lhs_end :: Maybe (Maybe Int)),+               ("rhs_begin",) . showValue <$>+                 (args !? #rhs_begin :: Maybe (Maybe Int)),+               ("rhs_end",) . showValue <$>+                 (args !? #rhs_end :: Maybe (Maybe Int))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "shape_array"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "size_array(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++size_array ::+           forall args . Fullfilled "size_array(symbol)" args =>+             String -> ArgsHMap "size_array(symbol)" args -> IO SymbolHandle+size_array name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "size_array"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Cast(symbol)" =+     '[ '("dtype",+          AttrReq+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("data", AttrOpt SymbolHandle)]++_Cast ::+      forall args . Fullfilled "_Cast(symbol)" args =>+        String -> ArgsHMap "_Cast(symbol)" args -> IO SymbolHandle+_Cast name args+  = let scalarArgs+          = catMaybes+              [("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Cast"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_cast(symbol)" = '[]++_backward_cast ::+               forall args . Fullfilled "_backward_cast(symbol)" args =>+                 String -> ArgsHMap "_backward_cast(symbol)" args -> IO SymbolHandle+_backward_cast name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cast"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "negative(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++negative ::+         forall args . Fullfilled "negative(symbol)" args =>+           String -> ArgsHMap "negative(symbol)" args -> IO SymbolHandle+negative name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "negative"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "reciprocal(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++reciprocal ::+           forall args . Fullfilled "reciprocal(symbol)" args =>+             String -> ArgsHMap "reciprocal(symbol)" args -> IO SymbolHandle+reciprocal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reciprocal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_reciprocal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_reciprocal ::+                     forall args . Fullfilled "_backward_reciprocal(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_reciprocal(symbol)" args -> IO SymbolHandle+_backward_reciprocal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_reciprocal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "abs(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++abs ::+    forall args . Fullfilled "abs(symbol)" args =>+      String -> ArgsHMap "abs(symbol)" args -> IO SymbolHandle+abs name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "abs"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_abs(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_abs ::+              forall args . Fullfilled "_backward_abs(symbol)" args =>+                String -> ArgsHMap "_backward_abs(symbol)" args -> IO SymbolHandle+_backward_abs name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_abs"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sign(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++sign ::+     forall args . Fullfilled "sign(symbol)" args =>+       String -> ArgsHMap "sign(symbol)" args -> IO SymbolHandle+sign name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sign"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sign(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_sign ::+               forall args . Fullfilled "_backward_sign(symbol)" args =>+                 String -> ArgsHMap "_backward_sign(symbol)" args -> IO SymbolHandle+_backward_sign name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sign"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "round(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++round ::+      forall args . Fullfilled "round(symbol)" args =>+        String -> ArgsHMap "round(symbol)" args -> IO SymbolHandle+round name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "round"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "rint(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++rint ::+     forall args . Fullfilled "rint(symbol)" args =>+       String -> ArgsHMap "rint(symbol)" args -> IO SymbolHandle+rint name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rint"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "ceil(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++ceil ::+     forall args . Fullfilled "ceil(symbol)" args =>+       String -> ArgsHMap "ceil(symbol)" args -> IO SymbolHandle+ceil name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ceil"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "floor(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++floor ::+      forall args . Fullfilled "floor(symbol)" args =>+        String -> ArgsHMap "floor(symbol)" args -> IO SymbolHandle+floor name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "floor"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "trunc(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++trunc ::+      forall args . Fullfilled "trunc(symbol)" args =>+        String -> ArgsHMap "trunc(symbol)" args -> IO SymbolHandle+trunc name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "trunc"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "fix(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++fix ::+    forall args . Fullfilled "fix(symbol)" args =>+      String -> ArgsHMap "fix(symbol)" args -> IO SymbolHandle+fix name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "fix"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "square(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++square ::+       forall args . Fullfilled "square(symbol)" args =>+         String -> ArgsHMap "square(symbol)" args -> IO SymbolHandle+square name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "square"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_square(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_square ::+                 forall args . Fullfilled "_backward_square(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_square(symbol)" args -> IO SymbolHandle+_backward_square name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_square"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sqrt(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++sqrt ::+     forall args . Fullfilled "sqrt(symbol)" args =>+       String -> ArgsHMap "sqrt(symbol)" args -> IO SymbolHandle+sqrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sqrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sqrt(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_sqrt ::+               forall args . Fullfilled "_backward_sqrt(symbol)" args =>+                 String -> ArgsHMap "_backward_sqrt(symbol)" args -> IO SymbolHandle+_backward_sqrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sqrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "rsqrt(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++rsqrt ::+      forall args . Fullfilled "rsqrt(symbol)" args =>+        String -> ArgsHMap "rsqrt(symbol)" args -> IO SymbolHandle+rsqrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rsqrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_rsqrt(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_rsqrt ::+                forall args . Fullfilled "_backward_rsqrt(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_rsqrt(symbol)" args -> IO SymbolHandle+_backward_rsqrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rsqrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "cbrt(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++cbrt ::+     forall args . Fullfilled "cbrt(symbol)" args =>+       String -> ArgsHMap "cbrt(symbol)" args -> IO SymbolHandle+cbrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cbrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_cbrt(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_cbrt ::+               forall args . Fullfilled "_backward_cbrt(symbol)" args =>+                 String -> ArgsHMap "_backward_cbrt(symbol)" args -> IO SymbolHandle+_backward_cbrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cbrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "erf(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++erf ::+    forall args . Fullfilled "erf(symbol)" args =>+      String -> ArgsHMap "erf(symbol)" args -> IO SymbolHandle+erf name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "erf"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_erf(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_erf ::+              forall args . Fullfilled "_backward_erf(symbol)" args =>+                String -> ArgsHMap "_backward_erf(symbol)" args -> IO SymbolHandle+_backward_erf name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_erf"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "rcbrt(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++rcbrt ::+      forall args . Fullfilled "rcbrt(symbol)" args =>+        String -> ArgsHMap "rcbrt(symbol)" args -> IO SymbolHandle+rcbrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rcbrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_rcbrt(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_rcbrt ::+                forall args . Fullfilled "_backward_rcbrt(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_rcbrt(symbol)" args -> IO SymbolHandle+_backward_rcbrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rcbrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "exp(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++exp ::+    forall args . Fullfilled "exp(symbol)" args =>+      String -> ArgsHMap "exp(symbol)" args -> IO SymbolHandle+exp name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "exp"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "log(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++log ::+    forall args . Fullfilled "log(symbol)" args =>+      String -> ArgsHMap "log(symbol)" args -> IO SymbolHandle+log name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "log10(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++log10 ::+      forall args . Fullfilled "log10(symbol)" args =>+        String -> ArgsHMap "log10(symbol)" args -> IO SymbolHandle+log10 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log10"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "log2(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++log2 ::+     forall args . Fullfilled "log2(symbol)" args =>+       String -> ArgsHMap "log2(symbol)" args -> IO SymbolHandle+log2 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log2"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_log(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_log ::+              forall args . Fullfilled "_backward_log(symbol)" args =>+                String -> ArgsHMap "_backward_log(symbol)" args -> IO SymbolHandle+_backward_log name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_log10(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_log10 ::+                forall args . Fullfilled "_backward_log10(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_log10(symbol)" args -> IO SymbolHandle+_backward_log10 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log10"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_log2(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_log2 ::+               forall args . Fullfilled "_backward_log2(symbol)" args =>+                 String -> ArgsHMap "_backward_log2(symbol)" args -> IO SymbolHandle+_backward_log2 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log2"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "log1p(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++log1p ::+      forall args . Fullfilled "log1p(symbol)" args =>+        String -> ArgsHMap "log1p(symbol)" args -> IO SymbolHandle+log1p name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log1p"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_log1p(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_log1p ::+                forall args . Fullfilled "_backward_log1p(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_log1p(symbol)" args -> IO SymbolHandle+_backward_log1p name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log1p"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "expm1(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++expm1 ::+      forall args . Fullfilled "expm1(symbol)" args =>+        String -> ArgsHMap "expm1(symbol)" args -> IO SymbolHandle+expm1 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "expm1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_expm1(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_expm1 ::+                forall args . Fullfilled "_backward_expm1(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_expm1(symbol)" args -> IO SymbolHandle+_backward_expm1 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_expm1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "gamma(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++gamma ::+      forall args . Fullfilled "gamma(symbol)" args =>+        String -> ArgsHMap "gamma(symbol)" args -> IO SymbolHandle+gamma name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gamma"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_gamma(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_gamma ::+                forall args . Fullfilled "_backward_gamma(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_gamma(symbol)" args -> IO SymbolHandle+_backward_gamma name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_gamma"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "gammaln(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++gammaln ::+        forall args . Fullfilled "gammaln(symbol)" args =>+          String -> ArgsHMap "gammaln(symbol)" args -> IO SymbolHandle+gammaln name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gammaln"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_gammaln(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_gammaln ::+                  forall args . Fullfilled "_backward_gammaln(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_gammaln(symbol)" args -> IO SymbolHandle+_backward_gammaln name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_gammaln"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "logical_not(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++logical_not ::+            forall args . Fullfilled "logical_not(symbol)" args =>+              String -> ArgsHMap "logical_not(symbol)" args -> IO SymbolHandle+logical_not name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "logical_not"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sum(symbol)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++sum ::+    forall args . Fullfilled "sum(symbol)" args =>+      String -> ArgsHMap "sum(symbol)" args -> IO SymbolHandle+sum name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sum(symbol)" = '[]++_backward_sum ::+              forall args . Fullfilled "_backward_sum(symbol)" args =>+                String -> ArgsHMap "_backward_sum(symbol)" args -> IO SymbolHandle+_backward_sum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "mean(symbol)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++mean ::+     forall args . Fullfilled "mean(symbol)" args =>+       String -> ArgsHMap "mean(symbol)" args -> IO SymbolHandle+mean name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mean"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_mean(symbol)" = '[]++_backward_mean ::+               forall args . Fullfilled "_backward_mean(symbol)" args =>+                 String -> ArgsHMap "_backward_mean(symbol)" args -> IO SymbolHandle+_backward_mean name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mean"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "prod(symbol)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++prod ::+     forall args . Fullfilled "prod(symbol)" args =>+       String -> ArgsHMap "prod(symbol)" args -> IO SymbolHandle+prod name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "prod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_prod(symbol)" = '[]++_backward_prod ::+               forall args . Fullfilled "_backward_prod(symbol)" args =>+                 String -> ArgsHMap "_backward_prod(symbol)" args -> IO SymbolHandle+_backward_prod name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_prod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "nansum(symbol)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++nansum ::+       forall args . Fullfilled "nansum(symbol)" args =>+         String -> ArgsHMap "nansum(symbol)" args -> IO SymbolHandle+nansum name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "nansum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_nansum(symbol)" = '[]++_backward_nansum ::+                 forall args . Fullfilled "_backward_nansum(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_nansum(symbol)" args -> IO SymbolHandle+_backward_nansum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_nansum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "nanprod(symbol)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++nanprod ::+        forall args . Fullfilled "nanprod(symbol)" args =>+          String -> ArgsHMap "nanprod(symbol)" args -> IO SymbolHandle+nanprod name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "nanprod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_nanprod(symbol)" = '[]++_backward_nanprod ::+                  forall args . Fullfilled "_backward_nanprod(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_nanprod(symbol)" args -> IO SymbolHandle+_backward_nanprod name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_nanprod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "max(symbol)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++max ::+    forall args . Fullfilled "max(symbol)" args =>+      String -> ArgsHMap "max(symbol)" args -> IO SymbolHandle+max name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "max"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_max(symbol)" = '[]++_backward_max ::+              forall args . Fullfilled "_backward_max(symbol)" args =>+                String -> ArgsHMap "_backward_max(symbol)" args -> IO SymbolHandle+_backward_max name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_max"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "min(symbol)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++min ::+    forall args . Fullfilled "min(symbol)" args =>+      String -> ArgsHMap "min(symbol)" args -> IO SymbolHandle+min name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "min"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_min(symbol)" = '[]++_backward_min ::+              forall args . Fullfilled "_backward_min(symbol)" args =>+                String -> ArgsHMap "_backward_min(symbol)" args -> IO SymbolHandle+_backward_min name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_min"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_axis(symbol)" =+     '[ '("axis", AttrOpt [Int]), '("size", AttrOpt [Int]),+        '("data", AttrOpt SymbolHandle)]++broadcast_axis ::+               forall args . Fullfilled "broadcast_axis(symbol)" args =>+                 String -> ArgsHMap "broadcast_axis(symbol)" args -> IO SymbolHandle+broadcast_axis name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),+               ("size",) . showValue <$> (args !? #size :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_axis"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_to(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]++broadcast_to ::+             forall args . Fullfilled "broadcast_to(symbol)" args =>+               String -> ArgsHMap "broadcast_to(symbol)" args -> IO SymbolHandle+broadcast_to name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_to"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_broadcast_backward(symbol)" = '[]++_broadcast_backward ::+                    forall args . Fullfilled "_broadcast_backward(symbol)" args =>+                      String ->+                        ArgsHMap "_broadcast_backward(symbol)" args -> IO SymbolHandle+_broadcast_backward name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_broadcast_backward"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_like(symbol)" =+     '[ '("lhs_axes", AttrOpt (Maybe [Int])),+        '("rhs_axes", AttrOpt (Maybe [Int])),+        '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_like ::+               forall args . Fullfilled "broadcast_like(symbol)" args =>+                 String -> ArgsHMap "broadcast_like(symbol)" args -> IO SymbolHandle+broadcast_like name args+  = let scalarArgs+          = catMaybes+              [("lhs_axes",) . showValue <$>+                 (args !? #lhs_axes :: Maybe (Maybe [Int])),+               ("rhs_axes",) . showValue <$>+                 (args !? #rhs_axes :: Maybe (Maybe [Int]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "norm(symbol)" =+     '[ '("ord", AttrOpt Int), '("axis", AttrOpt (Maybe [Int])),+        '("keepdims", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++norm ::+     forall args . Fullfilled "norm(symbol)" args =>+       String -> ArgsHMap "norm(symbol)" args -> IO SymbolHandle+norm name args+  = let scalarArgs+          = catMaybes+              [("ord",) . showValue <$> (args !? #ord :: Maybe Int),+               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "norm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_norm(symbol)" = '[]++_backward_norm ::+               forall args . Fullfilled "_backward_norm(symbol)" args =>+                 String -> ArgsHMap "_backward_norm(symbol)" args -> IO SymbolHandle+_backward_norm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_norm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "elemwise_add(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++elemwise_add ::+             forall args . Fullfilled "elemwise_add(symbol)" args =>+               String -> ArgsHMap "elemwise_add(symbol)" args -> IO SymbolHandle+elemwise_add name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_add"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_grad_add(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_grad_add ::+          forall args . Fullfilled "_grad_add(symbol)" args =>+            String -> ArgsHMap "_grad_add(symbol)" args -> IO SymbolHandle+_grad_add name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_grad_add"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_add(symbol)" = '[]++_backward_add ::+              forall args . Fullfilled "_backward_add(symbol)" args =>+                String -> ArgsHMap "_backward_add(symbol)" args -> IO SymbolHandle+_backward_add name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_add"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "elemwise_sub(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++elemwise_sub ::+             forall args . Fullfilled "elemwise_sub(symbol)" args =>+               String -> ArgsHMap "elemwise_sub(symbol)" args -> IO SymbolHandle+elemwise_sub name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_sub"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sub(symbol)" = '[]++_backward_sub ::+              forall args . Fullfilled "_backward_sub(symbol)" args =>+                String -> ArgsHMap "_backward_sub(symbol)" args -> IO SymbolHandle+_backward_sub name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sub"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "elemwise_mul(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++elemwise_mul ::+             forall args . Fullfilled "elemwise_mul(symbol)" args =>+               String -> ArgsHMap "elemwise_mul(symbol)" args -> IO SymbolHandle+elemwise_mul name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_mul"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_mul(symbol)" = '[]++_backward_mul ::+              forall args . Fullfilled "_backward_mul(symbol)" args =>+                String -> ArgsHMap "_backward_mul(symbol)" args -> IO SymbolHandle+_backward_mul name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mul"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "elemwise_div(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++elemwise_div ::+             forall args . Fullfilled "elemwise_div(symbol)" args =>+               String -> ArgsHMap "elemwise_div(symbol)" args -> IO SymbolHandle+elemwise_div name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_div"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_div(symbol)" = '[]++_backward_div ::+              forall args . Fullfilled "_backward_div(symbol)" args =>+                String -> ArgsHMap "_backward_div(symbol)" args -> IO SymbolHandle+_backward_div name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_div"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_mod(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_mod ::+     forall args . Fullfilled "_mod(symbol)" args =>+       String -> ArgsHMap "_mod(symbol)" args -> IO SymbolHandle+_mod name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_mod(symbol)" = '[]++_backward_mod ::+              forall args . Fullfilled "_backward_mod(symbol)" args =>+                String -> ArgsHMap "_backward_mod(symbol)" args -> IO SymbolHandle+_backward_mod name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_scatter_elemwise_div(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_scatter_elemwise_div ::+                      forall args . Fullfilled "_scatter_elemwise_div(symbol)" args =>+                        String ->+                          ArgsHMap "_scatter_elemwise_div(symbol)" args -> IO SymbolHandle+_scatter_elemwise_div name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_elemwise_div"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_scatter_plus_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_scatter_plus_scalar ::+                     forall args . Fullfilled "_scatter_plus_scalar(symbol)" args =>+                       String ->+                         ArgsHMap "_scatter_plus_scalar(symbol)" args -> IO SymbolHandle+_scatter_plus_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_plus_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_scatter_minus_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_scatter_minus_scalar ::+                      forall args . Fullfilled "_scatter_minus_scalar(symbol)" args =>+                        String ->+                          ArgsHMap "_scatter_minus_scalar(symbol)" args -> IO SymbolHandle+_scatter_minus_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_minus_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Embedding(symbol)" =+     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("sparse_grad", AttrOpt Bool), '("data", AttrOpt SymbolHandle),+        '("weight", AttrOpt SymbolHandle)]++_Embedding ::+           forall args . Fullfilled "_Embedding(symbol)" args =>+             String -> ArgsHMap "_Embedding(symbol)" args -> IO SymbolHandle+_Embedding name args+  = let scalarArgs+          = catMaybes+              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"])),+               ("sparse_grad",) . showValue <$>+                 (args !? #sparse_grad :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Embedding"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_SparseEmbedding(symbol)" =+     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("sparse_grad", AttrOpt Bool), '("data", AttrOpt SymbolHandle),+        '("weight", AttrOpt SymbolHandle)]++_contrib_SparseEmbedding ::+                         forall args . Fullfilled "_contrib_SparseEmbedding(symbol)" args =>+                           String ->+                             ArgsHMap "_contrib_SparseEmbedding(symbol)" args -> IO SymbolHandle+_contrib_SparseEmbedding name args+  = let scalarArgs+          = catMaybes+              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"])),+               ("sparse_grad",) . showValue <$>+                 (args !? #sparse_grad :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_SparseEmbedding"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Embedding(symbol)" = '[]++_backward_Embedding ::+                    forall args . Fullfilled "_backward_Embedding(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_Embedding(symbol)" args -> IO SymbolHandle+_backward_Embedding name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Embedding"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SparseEmbedding(symbol)" =+     '[]++_backward_SparseEmbedding ::+                          forall args .+                            Fullfilled "_backward_SparseEmbedding(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_SparseEmbedding(symbol)" args ->+                                IO SymbolHandle+_backward_SparseEmbedding name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SparseEmbedding"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "take(symbol)" =+     '[ '("axis", AttrOpt Int),+        '("mode", AttrOpt (EnumType '["clip", "raise", "wrap"])),+        '("a", AttrOpt SymbolHandle), '("indices", AttrOpt SymbolHandle)]++take ::+     forall args . Fullfilled "take(symbol)" args =>+       String -> ArgsHMap "take(symbol)" args -> IO SymbolHandle+take name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("a",) <$> (args !? #a :: Maybe SymbolHandle),+               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "take"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_take(symbol)" = '[]++_backward_take ::+               forall args . Fullfilled "_backward_take(symbol)" args =>+                 String -> ArgsHMap "_backward_take(symbol)" args -> IO SymbolHandle+_backward_take name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_take"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "batch_take(symbol)" =+     '[ '("a", AttrOpt SymbolHandle),+        '("indices", AttrOpt SymbolHandle)]++batch_take ::+           forall args . Fullfilled "batch_take(symbol)" args =>+             String -> ArgsHMap "batch_take(symbol)" args -> IO SymbolHandle+batch_take name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("a",) <$> (args !? #a :: Maybe SymbolHandle),+               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "batch_take"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "one_hot(symbol)" =+     '[ '("depth", AttrReq Int), '("on_value", AttrOpt Double),+        '("off_value", AttrOpt Double),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("indices", AttrOpt SymbolHandle)]++one_hot ::+        forall args . Fullfilled "one_hot(symbol)" args =>+          String -> ArgsHMap "one_hot(symbol)" args -> IO SymbolHandle+one_hot name args+  = let scalarArgs+          = catMaybes+              [("depth",) . showValue <$> (args !? #depth :: Maybe Int),+               ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double),+               ("off_value",) . showValue <$>+                 (args !? #off_value :: Maybe Double),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "one_hot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "gather_nd(symbol)" =+     '[ '("data", AttrOpt SymbolHandle),+        '("indices", AttrOpt SymbolHandle)]++gather_nd ::+          forall args . Fullfilled "gather_nd(symbol)" args =>+            String -> ArgsHMap "gather_nd(symbol)" args -> IO SymbolHandle+gather_nd name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gather_nd"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "scatter_nd(symbol)" =+     '[ '("shape", AttrReq [Int]), '("data", AttrOpt SymbolHandle),+        '("indices", AttrOpt SymbolHandle)]++scatter_nd ::+           forall args . Fullfilled "scatter_nd(symbol)" args =>+             String -> ArgsHMap "scatter_nd(symbol)" args -> IO SymbolHandle+scatter_nd name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "scatter_nd"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_gather_nd(symbol)" =+     '[ '("shape", AttrReq [Int]), '("data", AttrOpt SymbolHandle),+        '("indices", AttrOpt SymbolHandle)]++_backward_gather_nd ::+                    forall args . Fullfilled "_backward_gather_nd(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_gather_nd(symbol)" args -> IO SymbolHandle+_backward_gather_nd name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_gather_nd"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_scatter_set_nd(symbol)" =+     '[ '("shape", AttrReq [Int]), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle), '("indices", AttrOpt SymbolHandle)]++_scatter_set_nd ::+                forall args . Fullfilled "_scatter_set_nd(symbol)" args =>+                  String ->+                    ArgsHMap "_scatter_set_nd(symbol)" args -> IO SymbolHandle+_scatter_set_nd name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle),+               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_set_nd"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_equal ::+                forall args . Fullfilled "broadcast_equal(symbol)" args =>+                  String ->+                    ArgsHMap "broadcast_equal(symbol)" args -> IO SymbolHandle+broadcast_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_not_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_not_equal ::+                    forall args . Fullfilled "broadcast_not_equal(symbol)" args =>+                      String ->+                        ArgsHMap "broadcast_not_equal(symbol)" args -> IO SymbolHandle+broadcast_not_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_not_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_greater(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_greater ::+                  forall args . Fullfilled "broadcast_greater(symbol)" args =>+                    String ->+                      ArgsHMap "broadcast_greater(symbol)" args -> IO SymbolHandle+broadcast_greater name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_greater"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_greater_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_greater_equal ::+                        forall args . Fullfilled "broadcast_greater_equal(symbol)" args =>+                          String ->+                            ArgsHMap "broadcast_greater_equal(symbol)" args -> IO SymbolHandle+broadcast_greater_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_greater_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_lesser(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_lesser ::+                 forall args . Fullfilled "broadcast_lesser(symbol)" args =>+                   String ->+                     ArgsHMap "broadcast_lesser(symbol)" args -> IO SymbolHandle+broadcast_lesser name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_lesser"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_lesser_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_lesser_equal ::+                       forall args . Fullfilled "broadcast_lesser_equal(symbol)" args =>+                         String ->+                           ArgsHMap "broadcast_lesser_equal(symbol)" args -> IO SymbolHandle+broadcast_lesser_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_lesser_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_logical_and(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_logical_and ::+                      forall args . Fullfilled "broadcast_logical_and(symbol)" args =>+                        String ->+                          ArgsHMap "broadcast_logical_and(symbol)" args -> IO SymbolHandle+broadcast_logical_and name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_logical_and"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_logical_or(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_logical_or ::+                     forall args . Fullfilled "broadcast_logical_or(symbol)" args =>+                       String ->+                         ArgsHMap "broadcast_logical_or(symbol)" args -> IO SymbolHandle+broadcast_logical_or name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_logical_or"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_logical_xor(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_logical_xor ::+                      forall args . Fullfilled "broadcast_logical_xor(symbol)" args =>+                        String ->+                          ArgsHMap "broadcast_logical_xor(symbol)" args -> IO SymbolHandle+broadcast_logical_xor name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_logical_xor"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_plus_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_plus_scalar ::+             forall args . Fullfilled "_plus_scalar(symbol)" args =>+               String -> ArgsHMap "_plus_scalar(symbol)" args -> IO SymbolHandle+_plus_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_plus_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_minus_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_minus_scalar ::+              forall args . Fullfilled "_minus_scalar(symbol)" args =>+                String -> ArgsHMap "_minus_scalar(symbol)" args -> IO SymbolHandle+_minus_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minus_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_rminus_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_rminus_scalar ::+               forall args . Fullfilled "_rminus_scalar(symbol)" args =>+                 String -> ArgsHMap "_rminus_scalar(symbol)" args -> IO SymbolHandle+_rminus_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rminus_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_mul_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_mul_scalar ::+            forall args . Fullfilled "_mul_scalar(symbol)" args =>+              String -> ArgsHMap "_mul_scalar(symbol)" args -> IO SymbolHandle+_mul_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mul_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_mul_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_backward_mul_scalar ::+                     forall args . Fullfilled "_backward_mul_scalar(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_mul_scalar(symbol)" args -> IO SymbolHandle+_backward_mul_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mul_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_div_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_div_scalar ::+            forall args . Fullfilled "_div_scalar(symbol)" args =>+              String -> ArgsHMap "_div_scalar(symbol)" args -> IO SymbolHandle+_div_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_div_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_div_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_backward_div_scalar ::+                     forall args . Fullfilled "_backward_div_scalar(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_div_scalar(symbol)" args -> IO SymbolHandle+_backward_div_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_div_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_rdiv_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_rdiv_scalar ::+             forall args . Fullfilled "_rdiv_scalar(symbol)" args =>+               String -> ArgsHMap "_rdiv_scalar(symbol)" args -> IO SymbolHandle+_rdiv_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rdiv_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_rdiv_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_rdiv_scalar ::+                      forall args . Fullfilled "_backward_rdiv_scalar(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_rdiv_scalar(symbol)" args -> IO SymbolHandle+_backward_rdiv_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rdiv_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_mod_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_mod_scalar ::+            forall args . Fullfilled "_mod_scalar(symbol)" args =>+              String -> ArgsHMap "_mod_scalar(symbol)" args -> IO SymbolHandle+_mod_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mod_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_mod_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_mod_scalar ::+                     forall args . Fullfilled "_backward_mod_scalar(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_mod_scalar(symbol)" args -> IO SymbolHandle+_backward_mod_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mod_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_rmod_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_rmod_scalar ::+             forall args . Fullfilled "_rmod_scalar(symbol)" args =>+               String -> ArgsHMap "_rmod_scalar(symbol)" args -> IO SymbolHandle+_rmod_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rmod_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_rmod_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_rmod_scalar ::+                      forall args . Fullfilled "_backward_rmod_scalar(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_rmod_scalar(symbol)" args -> IO SymbolHandle+_backward_rmod_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rmod_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_ravel_multi_index(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]++_ravel_multi_index ::+                   forall args . Fullfilled "_ravel_multi_index(symbol)" args =>+                     String ->+                       ArgsHMap "_ravel_multi_index(symbol)" args -> IO SymbolHandle+_ravel_multi_index name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_ravel_multi_index"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_unravel_index(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]++_unravel_index ::+               forall args . Fullfilled "_unravel_index(symbol)" args =>+                 String -> ArgsHMap "_unravel_index(symbol)" args -> IO SymbolHandle+_unravel_index name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_unravel_index"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "argmax(symbol)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle)]++argmax ::+       forall args . Fullfilled "argmax(symbol)" args =>+         String -> ArgsHMap "argmax(symbol)" args -> IO SymbolHandle+argmax name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmax"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "argmin(symbol)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle)]++argmin ::+       forall args . Fullfilled "argmin(symbol)" args =>+         String -> ArgsHMap "argmin(symbol)" args -> IO SymbolHandle+argmin name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmin"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "argmax_channel(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++argmax_channel ::+               forall args . Fullfilled "argmax_channel(symbol)" args =>+                 String -> ArgsHMap "argmax_channel(symbol)" args -> IO SymbolHandle+argmax_channel name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmax_channel"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "pick(symbol)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),+        '("mode", AttrOpt (EnumType '["clip", "wrap"])),+        '("data", AttrOpt SymbolHandle), '("index", AttrOpt SymbolHandle)]++pick ::+     forall args . Fullfilled "pick(symbol)" args =>+       String -> ArgsHMap "pick(symbol)" args -> IO SymbolHandle+pick name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["clip", "wrap"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("index",) <$> (args !? #index :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "pick"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_pick(symbol)" = '[]++_backward_pick ::+               forall args . Fullfilled "_backward_pick(symbol)" args =>+                 String -> ArgsHMap "_backward_pick(symbol)" args -> IO SymbolHandle+_backward_pick name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_pick"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sparse_retain(symbol)" =+     '[ '("data", AttrOpt SymbolHandle),+        '("indices", AttrOpt SymbolHandle)]++_sparse_retain ::+               forall args . Fullfilled "_sparse_retain(symbol)" args =>+                 String -> ArgsHMap "_sparse_retain(symbol)" args -> IO SymbolHandle+_sparse_retain name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sparse_retain"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sparse_retain(symbol)" = '[]++_backward_sparse_retain ::+                        forall args . Fullfilled "_backward_sparse_retain(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_sparse_retain(symbol)" args -> IO SymbolHandle+_backward_sparse_retain name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sparse_retain"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_where(symbol)" =+     '[ '("condition", AttrOpt SymbolHandle),+        '("x", AttrOpt SymbolHandle), '("y", AttrOpt SymbolHandle)]++_where ::+       forall args . Fullfilled "_where(symbol)" args =>+         String -> ArgsHMap "_where(symbol)" args -> IO SymbolHandle+_where name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("condition",) <$> (args !? #condition :: Maybe SymbolHandle),+               ("x",) <$> (args !? #x :: Maybe SymbolHandle),+               ("y",) <$> (args !? #y :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "where"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_where(symbol)" = '[]++_backward_where ::+                forall args . Fullfilled "_backward_where(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_where(symbol)" args -> IO SymbolHandle+_backward_where name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_where"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "diag(symbol)" =+     '[ '("k", AttrOpt Int), '("axis1", AttrOpt Int),+        '("axis2", AttrOpt Int), '("data", AttrOpt SymbolHandle)]++diag ::+     forall args . Fullfilled "diag(symbol)" args =>+       String -> ArgsHMap "diag(symbol)" args -> IO SymbolHandle+diag name args+  = let scalarArgs+          = catMaybes+              [("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("axis1",) . showValue <$> (args !? #axis1 :: Maybe Int),+               ("axis2",) . showValue <$> (args !? #axis2 :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "diag"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_diag(symbol)" = '[]++_backward_diag ::+               forall args . Fullfilled "_backward_diag(symbol)" args =>+                 String -> ArgsHMap "_backward_diag(symbol)" args -> IO SymbolHandle+_backward_diag name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_diag"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_maximum_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_maximum_scalar ::+                forall args . Fullfilled "_maximum_scalar(symbol)" args =>+                  String ->+                    ArgsHMap "_maximum_scalar(symbol)" args -> IO SymbolHandle+_maximum_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_maximum_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_maximum_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_maximum_scalar ::+                         forall args . Fullfilled "_backward_maximum_scalar(symbol)" args =>+                           String ->+                             ArgsHMap "_backward_maximum_scalar(symbol)" args -> IO SymbolHandle+_backward_maximum_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_maximum_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_minimum_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_minimum_scalar ::+                forall args . Fullfilled "_minimum_scalar(symbol)" args =>+                  String ->+                    ArgsHMap "_minimum_scalar(symbol)" args -> IO SymbolHandle+_minimum_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minimum_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_minimum_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_minimum_scalar ::+                         forall args . Fullfilled "_backward_minimum_scalar(symbol)" args =>+                           String ->+                             ArgsHMap "_backward_minimum_scalar(symbol)" args -> IO SymbolHandle+_backward_minimum_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_minimum_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_power_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_power_scalar ::+              forall args . Fullfilled "_power_scalar(symbol)" args =>+                String -> ArgsHMap "_power_scalar(symbol)" args -> IO SymbolHandle+_power_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_power_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_power_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_power_scalar ::+                       forall args . Fullfilled "_backward_power_scalar(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_power_scalar(symbol)" args -> IO SymbolHandle+_backward_power_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_power_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_rpower_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_rpower_scalar ::+               forall args . Fullfilled "_rpower_scalar(symbol)" args =>+                 String -> ArgsHMap "_rpower_scalar(symbol)" args -> IO SymbolHandle+_rpower_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rpower_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_rpower_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_rpower_scalar ::+                        forall args . Fullfilled "_backward_rpower_scalar(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_rpower_scalar(symbol)" args -> IO SymbolHandle+_backward_rpower_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rpower_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_hypot_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_hypot_scalar ::+              forall args . Fullfilled "_hypot_scalar(symbol)" args =>+                String -> ArgsHMap "_hypot_scalar(symbol)" args -> IO SymbolHandle+_hypot_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_hypot_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_hypot_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_hypot_scalar ::+                       forall args . Fullfilled "_backward_hypot_scalar(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_hypot_scalar(symbol)" args -> IO SymbolHandle+_backward_hypot_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_hypot_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "smooth_l1(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++smooth_l1 ::+          forall args . Fullfilled "smooth_l1(symbol)" args =>+            String -> ArgsHMap "smooth_l1(symbol)" args -> IO SymbolHandle+smooth_l1 name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "smooth_l1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_smooth_l1(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_smooth_l1 ::+                    forall args . Fullfilled "_backward_smooth_l1(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_smooth_l1(symbol)" args -> IO SymbolHandle+_backward_smooth_l1 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_smooth_l1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "topk(symbol)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("k", AttrOpt Int),+        '("ret_typ",+          AttrOpt (EnumType '["both", "indices", "mask", "value"])),+        '("is_ascend", AttrOpt Bool),+        '("dtype",+          AttrOpt+            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),+        '("data", AttrOpt SymbolHandle)]++topk ::+     forall args . Fullfilled "topk(symbol)" args =>+       String -> ArgsHMap "topk(symbol)" args -> IO SymbolHandle+topk name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("ret_typ",) . showValue <$>+                 (args !? #ret_typ ::+                    Maybe (EnumType '["both", "indices", "mask", "value"])),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "topk"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_topk(symbol)" = '[]++_backward_topk ::+               forall args . Fullfilled "_backward_topk(symbol)" args =>+                 String -> ArgsHMap "_backward_topk(symbol)" args -> IO SymbolHandle+_backward_topk name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_topk"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sort(symbol)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle)]++sort ::+     forall args . Fullfilled "sort(symbol)" args =>+       String -> ArgsHMap "sort(symbol)" args -> IO SymbolHandle+sort name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sort"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "argsort(symbol)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),+        '("dtype",+          AttrOpt+            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),+        '("data", AttrOpt SymbolHandle)]++argsort ::+        forall args . Fullfilled "argsort(symbol)" args =>+          String -> ArgsHMap "argsort(symbol)" args -> IO SymbolHandle+argsort name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argsort"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Reshape(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("reverse", AttrOpt Bool),+        '("target_shape", AttrOpt [Int]), '("keep_highest", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle)]++_Reshape ::+         forall args . Fullfilled "_Reshape(symbol)" args =>+           String -> ArgsHMap "_Reshape(symbol)" args -> IO SymbolHandle+_Reshape name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("keep_highest",) . showValue <$>+                 (args !? #keep_highest :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Reshape"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Flatten(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++_Flatten ::+         forall args . Fullfilled "_Flatten(symbol)" args =>+           String -> ArgsHMap "_Flatten(symbol)" args -> IO SymbolHandle+_Flatten name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Flatten"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "transpose(symbol)" =+     '[ '("axes", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]++transpose ::+          forall args . Fullfilled "transpose(symbol)" args =>+            String -> ArgsHMap "transpose(symbol)" args -> IO SymbolHandle+transpose name args+  = let scalarArgs+          = catMaybes+              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "transpose"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "expand_dims(symbol)" =+     '[ '("axis", AttrReq Int), '("data", AttrOpt SymbolHandle)]++expand_dims ::+            forall args . Fullfilled "expand_dims(symbol)" args =>+              String -> ArgsHMap "expand_dims(symbol)" args -> IO SymbolHandle+expand_dims name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "expand_dims"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "slice(symbol)" =+     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),+        '("step", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]++slice ::+      forall args . Fullfilled "slice(symbol)" args =>+        String -> ArgsHMap "slice(symbol)" args -> IO SymbolHandle+slice name args+  = let scalarArgs+          = catMaybes+              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "slice"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_slice(symbol)" = '[]++_backward_slice ::+                forall args . Fullfilled "_backward_slice(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_slice(symbol)" args -> IO SymbolHandle+_backward_slice name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_slice"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_slice_assign(symbol)" =+     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),+        '("step", AttrOpt [Int]), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_slice_assign ::+              forall args . Fullfilled "_slice_assign(symbol)" args =>+                String -> ArgsHMap "_slice_assign(symbol)" args -> IO SymbolHandle+_slice_assign name args+  = let scalarArgs+          = catMaybes+              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_slice_assign"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_slice_assign_scalar(symbol)" =+     '[ '("scalar", AttrOpt Double), '("begin", AttrReq [Int]),+        '("end", AttrReq [Int]), '("step", AttrOpt [Int]),+        '("data", AttrOpt SymbolHandle)]++_slice_assign_scalar ::+                     forall args . Fullfilled "_slice_assign_scalar(symbol)" args =>+                       String ->+                         ArgsHMap "_slice_assign_scalar(symbol)" args -> IO SymbolHandle+_slice_assign_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Double),+               ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_slice_assign_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "slice_axis(symbol)" =+     '[ '("axis", AttrReq Int), '("begin", AttrReq Int),+        '("end", AttrReq (Maybe Int)), '("data", AttrOpt SymbolHandle)]++slice_axis ::+           forall args . Fullfilled "slice_axis(symbol)" args =>+             String -> ArgsHMap "slice_axis(symbol)" args -> IO SymbolHandle+slice_axis name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("begin",) . showValue <$> (args !? #begin :: Maybe Int),+               ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "slice_axis"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_slice_axis(symbol)" = '[]++_backward_slice_axis ::+                     forall args . Fullfilled "_backward_slice_axis(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_slice_axis(symbol)" args -> IO SymbolHandle+_backward_slice_axis name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_slice_axis"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "slice_like(symbol)" =+     '[ '("axes", AttrOpt [Int]), '("data", AttrOpt SymbolHandle),+        '("shape_like", AttrOpt SymbolHandle)]++slice_like ::+           forall args . Fullfilled "slice_like(symbol)" args =>+             String -> ArgsHMap "slice_like(symbol)" args -> IO SymbolHandle+slice_like name args+  = let scalarArgs+          = catMaybes+              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("shape_like",) <$> (args !? #shape_like :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "slice_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_slice_like(symbol)" = '[]++_backward_slice_like ::+                     forall args . Fullfilled "_backward_slice_like(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_slice_like(symbol)" args -> IO SymbolHandle+_backward_slice_like name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_slice_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "clip(symbol)" =+     '[ '("a_min", AttrReq Float), '("a_max", AttrReq Float),+        '("data", AttrOpt SymbolHandle)]++clip ::+     forall args . Fullfilled "clip(symbol)" args =>+       String -> ArgsHMap "clip(symbol)" args -> IO SymbolHandle+clip name args+  = let scalarArgs+          = catMaybes+              [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float),+               ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "clip"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_clip(symbol)" = '[]++_backward_clip ::+               forall args . Fullfilled "_backward_clip(symbol)" args =>+                 String -> ArgsHMap "_backward_clip(symbol)" args -> IO SymbolHandle+_backward_clip name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_clip"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "repeat(symbol)" =+     '[ '("repeats", AttrReq Int), '("axis", AttrOpt (Maybe Int)),+        '("data", AttrOpt SymbolHandle)]++repeat ::+       forall args . Fullfilled "repeat(symbol)" args =>+         String -> ArgsHMap "repeat(symbol)" args -> IO SymbolHandle+repeat name args+  = let scalarArgs+          = catMaybes+              [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int),+               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "repeat"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_repeat(symbol)" = '[]++_backward_repeat ::+                 forall args . Fullfilled "_backward_repeat(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_repeat(symbol)" args -> IO SymbolHandle+_backward_repeat name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_repeat"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "tile(symbol)" =+     '[ '("reps", AttrReq [Int]), '("data", AttrOpt SymbolHandle)]++tile ::+     forall args . Fullfilled "tile(symbol)" args =>+       String -> ArgsHMap "tile(symbol)" args -> IO SymbolHandle+tile name args+  = let scalarArgs+          = catMaybes+              [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tile"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_tile(symbol)" = '[]++_backward_tile ::+               forall args . Fullfilled "_backward_tile(symbol)" args =>+                 String -> ArgsHMap "_backward_tile(symbol)" args -> IO SymbolHandle+_backward_tile name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tile"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "reverse(symbol)" =+     '[ '("axis", AttrReq [Int]), '("data", AttrOpt SymbolHandle)]++reverse ::+        forall args . Fullfilled "reverse(symbol)" args =>+          String -> ArgsHMap "reverse(symbol)" args -> IO SymbolHandle+reverse name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reverse"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_reverse(symbol)" = '[]++_backward_reverse ::+                  forall args . Fullfilled "_backward_reverse(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_reverse(symbol)" args -> IO SymbolHandle+_backward_reverse name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_reverse"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "stack(symbol)" =+     '[ '("axis", AttrOpt Int), '("num_args", AttrReq Int),+        '("data", AttrOpt [SymbolHandle])]++stack ::+      forall args . Fullfilled "stack(symbol)" args =>+        String -> ArgsHMap "stack(symbol)" args -> IO SymbolHandle+stack name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "stack"+         sym <- if hasKey args #num_args then+                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals+                  else+                  mxSymbolCreateAtomicSymbol (fromOpHandle op)+                    ("num_args" : scalarkeys)+                    (showValue (length array) : scalarvals)+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_backward_stack(symbol)" = '[]++_backward_stack ::+                forall args . Fullfilled "_backward_stack(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_stack(symbol)" args -> IO SymbolHandle+_backward_stack name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_stack"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "squeeze(symbol)" =+     '[ '("axis", AttrOpt (Maybe [Int])),+        '("data", AttrOpt [SymbolHandle])]++squeeze ::+        forall args . Fullfilled "squeeze(symbol)" args =>+          String -> ArgsHMap "squeeze(symbol)" args -> IO SymbolHandle+squeeze name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "squeeze"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_backward_squeeze(symbol)" = '[]++_backward_squeeze ::+                  forall args . Fullfilled "_backward_squeeze(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_squeeze(symbol)" args -> IO SymbolHandle+_backward_squeeze name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_squeeze"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "depth_to_space(symbol)" =+     '[ '("block_size", AttrReq Int), '("data", AttrOpt SymbolHandle)]++depth_to_space ::+               forall args . Fullfilled "depth_to_space(symbol)" args =>+                 String -> ArgsHMap "depth_to_space(symbol)" args -> IO SymbolHandle+depth_to_space name args+  = let scalarArgs+          = catMaybes+              [("block_size",) . showValue <$>+                 (args !? #block_size :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "depth_to_space"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "space_to_depth(symbol)" =+     '[ '("block_size", AttrReq Int), '("data", AttrOpt SymbolHandle)]++space_to_depth ::+               forall args . Fullfilled "space_to_depth(symbol)" args =>+                 String -> ArgsHMap "space_to_depth(symbol)" args -> IO SymbolHandle+space_to_depth name args+  = let scalarArgs+          = catMaybes+              [("block_size",) . showValue <$>+                 (args !? #block_size :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "space_to_depth"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "dot(symbol)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("forward_stype",+          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))),+        '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++dot ::+    forall args . Fullfilled "dot(symbol)" args =>+      String -> ArgsHMap "dot(symbol)" args -> IO SymbolHandle+dot name args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("forward_stype",) . showValue <$>+                 (args !? #forward_stype ::+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "dot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_dot(symbol)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("forward_stype",+          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"])))]++_backward_dot ::+              forall args . Fullfilled "_backward_dot(symbol)" args =>+                String -> ArgsHMap "_backward_dot(symbol)" args -> IO SymbolHandle+_backward_dot name args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("forward_stype",) . showValue <$>+                 (args !? #forward_stype ::+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_dot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "batch_dot(symbol)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("forward_stype",+          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))),+        '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++batch_dot ::+          forall args . Fullfilled "batch_dot(symbol)" args =>+            String -> ArgsHMap "batch_dot(symbol)" args -> IO SymbolHandle+batch_dot name args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("forward_stype",) . showValue <$>+                 (args !? #forward_stype ::+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "batch_dot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_batch_dot(symbol)" = '[]++_backward_batch_dot ::+                    forall args . Fullfilled "_backward_batch_dot(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_batch_dot(symbol)" args -> IO SymbolHandle+_backward_batch_dot name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_batch_dot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sin(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++sin ::+    forall args . Fullfilled "sin(symbol)" args =>+      String -> ArgsHMap "sin(symbol)" args -> IO SymbolHandle+sin name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sin"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sin(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_sin ::+              forall args . Fullfilled "_backward_sin(symbol)" args =>+                String -> ArgsHMap "_backward_sin(symbol)" args -> IO SymbolHandle+_backward_sin name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sin"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "cos(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++cos ::+    forall args . Fullfilled "cos(symbol)" args =>+      String -> ArgsHMap "cos(symbol)" args -> IO SymbolHandle+cos name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cos"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_cos(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_cos ::+              forall args . Fullfilled "_backward_cos(symbol)" args =>+                String -> ArgsHMap "_backward_cos(symbol)" args -> IO SymbolHandle+_backward_cos name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cos"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "tan(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++tan ::+    forall args . Fullfilled "tan(symbol)" args =>+      String -> ArgsHMap "tan(symbol)" args -> IO SymbolHandle+tan name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tan"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_tan(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_tan ::+              forall args . Fullfilled "_backward_tan(symbol)" args =>+                String -> ArgsHMap "_backward_tan(symbol)" args -> IO SymbolHandle+_backward_tan name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tan"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "arcsin(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++arcsin ::+       forall args . Fullfilled "arcsin(symbol)" args =>+         String -> ArgsHMap "arcsin(symbol)" args -> IO SymbolHandle+arcsin name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arcsin"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_arcsin(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_arcsin ::+                 forall args . Fullfilled "_backward_arcsin(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_arcsin(symbol)" args -> IO SymbolHandle+_backward_arcsin name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arcsin"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "arccos(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++arccos ::+       forall args . Fullfilled "arccos(symbol)" args =>+         String -> ArgsHMap "arccos(symbol)" args -> IO SymbolHandle+arccos name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arccos"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_arccos(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_arccos ::+                 forall args . Fullfilled "_backward_arccos(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_arccos(symbol)" args -> IO SymbolHandle+_backward_arccos name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arccos"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "arctan(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++arctan ::+       forall args . Fullfilled "arctan(symbol)" args =>+         String -> ArgsHMap "arctan(symbol)" args -> IO SymbolHandle+arctan name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arctan"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_arctan(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_arctan ::+                 forall args . Fullfilled "_backward_arctan(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_arctan(symbol)" args -> IO SymbolHandle+_backward_arctan name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arctan"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "degrees(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++degrees ::+        forall args . Fullfilled "degrees(symbol)" args =>+          String -> ArgsHMap "degrees(symbol)" args -> IO SymbolHandle+degrees name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "degrees"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_degrees(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_degrees ::+                  forall args . Fullfilled "_backward_degrees(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_degrees(symbol)" args -> IO SymbolHandle+_backward_degrees name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_degrees"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "radians(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++radians ::+        forall args . Fullfilled "radians(symbol)" args =>+          String -> ArgsHMap "radians(symbol)" args -> IO SymbolHandle+radians name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "radians"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_radians(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_radians ::+                  forall args . Fullfilled "_backward_radians(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_radians(symbol)" args -> IO SymbolHandle+_backward_radians name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_radians"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sinh(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++sinh ::+     forall args . Fullfilled "sinh(symbol)" args =>+       String -> ArgsHMap "sinh(symbol)" args -> IO SymbolHandle+sinh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sinh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sinh(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_sinh ::+               forall args . Fullfilled "_backward_sinh(symbol)" args =>+                 String -> ArgsHMap "_backward_sinh(symbol)" args -> IO SymbolHandle+_backward_sinh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sinh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "cosh(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++cosh ::+     forall args . Fullfilled "cosh(symbol)" args =>+       String -> ArgsHMap "cosh(symbol)" args -> IO SymbolHandle+cosh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cosh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_cosh(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_cosh ::+               forall args . Fullfilled "_backward_cosh(symbol)" args =>+                 String -> ArgsHMap "_backward_cosh(symbol)" args -> IO SymbolHandle+_backward_cosh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cosh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "tanh(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++tanh ::+     forall args . Fullfilled "tanh(symbol)" args =>+       String -> ArgsHMap "tanh(symbol)" args -> IO SymbolHandle+tanh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tanh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_tanh(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_tanh ::+               forall args . Fullfilled "_backward_tanh(symbol)" args =>+                 String -> ArgsHMap "_backward_tanh(symbol)" args -> IO SymbolHandle+_backward_tanh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tanh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "arcsinh(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++arcsinh ::+        forall args . Fullfilled "arcsinh(symbol)" args =>+          String -> ArgsHMap "arcsinh(symbol)" args -> IO SymbolHandle+arcsinh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arcsinh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_arcsinh(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_arcsinh ::+                  forall args . Fullfilled "_backward_arcsinh(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_arcsinh(symbol)" args -> IO SymbolHandle+_backward_arcsinh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arcsinh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "arccosh(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++arccosh ::+        forall args . Fullfilled "arccosh(symbol)" args =>+          String -> ArgsHMap "arccosh(symbol)" args -> IO SymbolHandle+arccosh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arccosh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_arccosh(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_arccosh ::+                  forall args . Fullfilled "_backward_arccosh(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_arccosh(symbol)" args -> IO SymbolHandle+_backward_arccosh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arccosh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "arctanh(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++arctanh ::+        forall args . Fullfilled "arctanh(symbol)" args =>+          String -> ArgsHMap "arctanh(symbol)" args -> IO SymbolHandle+arctanh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arctanh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_arctanh(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_arctanh ::+                  forall args . Fullfilled "_backward_arctanh(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_arctanh(symbol)" args -> IO SymbolHandle+_backward_arctanh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arctanh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_group_adagrad_update(symbol)"+     =+     '[ '("lr", AttrReq Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("epsilon", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("history", AttrOpt SymbolHandle)]++_contrib_group_adagrad_update ::+                              forall args .+                                Fullfilled "_contrib_group_adagrad_update(symbol)" args =>+                                String ->+                                  ArgsHMap "_contrib_group_adagrad_update(symbol)" args ->+                                    IO SymbolHandle+_contrib_group_adagrad_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("history",) <$> (args !? #history :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_group_adagrad_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_getnnz(symbol)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("data", AttrOpt SymbolHandle)]++_contrib_getnnz ::+                forall args . Fullfilled "_contrib_getnnz(symbol)" args =>+                  String ->+                    ArgsHMap "_contrib_getnnz(symbol)" args -> IO SymbolHandle+_contrib_getnnz name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_getnnz"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_edge_id(symbol)" =+     '[ '("data", AttrOpt SymbolHandle), '("u", AttrOpt SymbolHandle),+        '("v", AttrOpt SymbolHandle)]++_contrib_edge_id ::+                 forall args . Fullfilled "_contrib_edge_id(symbol)" args =>+                   String ->+                     ArgsHMap "_contrib_edge_id(symbol)" args -> IO SymbolHandle+_contrib_edge_id name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("u",) <$> (args !? #u :: Maybe SymbolHandle),+               ("v",) <$> (args !? #v :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_edge_id"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_dgl_adjacency(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++_contrib_dgl_adjacency ::+                       forall args . Fullfilled "_contrib_dgl_adjacency(symbol)" args =>+                         String ->+                           ArgsHMap "_contrib_dgl_adjacency(symbol)" args -> IO SymbolHandle+_contrib_dgl_adjacency name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_dgl_adjacency"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_quadratic(symbol)" =+     '[ '("a", AttrOpt Float), '("b", AttrOpt Float),+        '("c", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_contrib_quadratic ::+                   forall args . Fullfilled "_contrib_quadratic(symbol)" args =>+                     String ->+                       ArgsHMap "_contrib_quadratic(symbol)" args -> IO SymbolHandle+_contrib_quadratic name args+  = let scalarArgs+          = catMaybes+              [("a",) . showValue <$> (args !? #a :: Maybe Float),+               ("b",) . showValue <$> (args !? #b :: Maybe Float),+               ("c",) . showValue <$> (args !? #c :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quadratic"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_backward_quadratic(symbol)" =+     '[]++_contrib_backward_quadratic ::+                            forall args .+                              Fullfilled "_contrib_backward_quadratic(symbol)" args =>+                              String ->+                                ArgsHMap "_contrib_backward_quadratic(symbol)" args ->+                                  IO SymbolHandle+_contrib_backward_quadratic name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_backward_quadratic"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_div_sqrt_dim(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++_contrib_div_sqrt_dim ::+                      forall args . Fullfilled "_contrib_div_sqrt_dim(symbol)" args =>+                        String ->+                          ArgsHMap "_contrib_div_sqrt_dim(symbol)" args -> IO SymbolHandle+_contrib_div_sqrt_dim name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_div_sqrt_dim"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "khatri_rao(symbol)" =+     '[ '("args", AttrOpt [SymbolHandle])]++khatri_rao ::+           forall args . Fullfilled "khatri_rao(symbol)" args =>+             String -> ArgsHMap "khatri_rao(symbol)" args -> IO SymbolHandle+khatri_rao name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "khatri_rao"+         sym <- if hasKey args #num_args then+                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals+                  else+                  mxSymbolCreateAtomicSymbol (fromOpHandle op)+                    ("num_args" : scalarkeys)+                    (showValue (length array) : scalarvals)+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_contrib_index_copy(symbol)" =+     '[ '("old_tensor", AttrOpt SymbolHandle),+        '("index_vector", AttrOpt SymbolHandle),+        '("new_tensor", AttrOpt SymbolHandle)]++_contrib_index_copy ::+                    forall args . Fullfilled "_contrib_index_copy(symbol)" args =>+                      String ->+                        ArgsHMap "_contrib_index_copy(symbol)" args -> IO SymbolHandle+_contrib_index_copy name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("old_tensor",) <$> (args !? #old_tensor :: Maybe SymbolHandle),+               ("index_vector",) <$>+                 (args !? #index_vector :: Maybe SymbolHandle),+               ("new_tensor",) <$> (args !? #new_tensor :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_index_copy"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_backward_index_copy(symbol)"+     = '[]++_contrib_backward_index_copy ::+                             forall args .+                               Fullfilled "_contrib_backward_index_copy(symbol)" args =>+                               String ->+                                 ArgsHMap "_contrib_backward_index_copy(symbol)" args ->+                                   IO SymbolHandle+_contrib_backward_index_copy name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_backward_index_copy"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_ROIAlign(symbol)" =+     '[ '("pooled_size", AttrReq [Int]),+        '("spatial_scale", AttrReq Float), '("sample_ratio", AttrOpt Int),+        '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle)]++_contrib_ROIAlign ::+                  forall args . Fullfilled "_contrib_ROIAlign(symbol)" args =>+                    String ->+                      ArgsHMap "_contrib_ROIAlign(symbol)" args -> IO SymbolHandle+_contrib_ROIAlign name args+  = let scalarArgs+          = catMaybes+              [("pooled_size",) . showValue <$>+                 (args !? #pooled_size :: Maybe [Int]),+               ("spatial_scale",) . showValue <$>+                 (args !? #spatial_scale :: Maybe Float),+               ("sample_ratio",) . showValue <$>+                 (args !? #sample_ratio :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_ROIAlign"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_ROIAlign(symbol)" = '[]++_backward_ROIAlign ::+                   forall args . Fullfilled "_backward_ROIAlign(symbol)" args =>+                     String ->+                       ArgsHMap "_backward_ROIAlign(symbol)" args -> IO SymbolHandle+_backward_ROIAlign name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_ROIAlign"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_box_nms(symbol)" =+     '[ '("overlap_thresh", AttrOpt Float),+        '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int),+        '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int),+        '("id_index", AttrOpt Int), '("force_suppress", AttrOpt Bool),+        '("in_format", AttrOpt (EnumType '["center", "corner"])),+        '("out_format", AttrOpt (EnumType '["center", "corner"])),+        '("data", AttrOpt SymbolHandle)]++_contrib_box_nms ::+                 forall args . Fullfilled "_contrib_box_nms(symbol)" args =>+                   String ->+                     ArgsHMap "_contrib_box_nms(symbol)" args -> IO SymbolHandle+_contrib_box_nms name args+  = let scalarArgs+          = catMaybes+              [("overlap_thresh",) . showValue <$>+                 (args !? #overlap_thresh :: Maybe Float),+               ("valid_thresh",) . showValue <$>+                 (args !? #valid_thresh :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),+               ("coord_start",) . showValue <$>+                 (args !? #coord_start :: Maybe Int),+               ("score_index",) . showValue <$>+                 (args !? #score_index :: Maybe Int),+               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),+               ("force_suppress",) . showValue <$>+                 (args !? #force_suppress :: Maybe Bool),+               ("in_format",) . showValue <$>+                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),+               ("out_format",) . showValue <$>+                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_box_nms"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_contrib_box_nms(symbol)" =+     '[ '("overlap_thresh", AttrOpt Float),+        '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int),+        '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int),+        '("id_index", AttrOpt Int), '("force_suppress", AttrOpt Bool),+        '("in_format", AttrOpt (EnumType '["center", "corner"])),+        '("out_format", AttrOpt (EnumType '["center", "corner"]))]++_backward_contrib_box_nms ::+                          forall args .+                            Fullfilled "_backward_contrib_box_nms(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_contrib_box_nms(symbol)" args ->+                                IO SymbolHandle+_backward_contrib_box_nms name args+  = let scalarArgs+          = catMaybes+              [("overlap_thresh",) . showValue <$>+                 (args !? #overlap_thresh :: Maybe Float),+               ("valid_thresh",) . showValue <$>+                 (args !? #valid_thresh :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),+               ("coord_start",) . showValue <$>+                 (args !? #coord_start :: Maybe Int),+               ("score_index",) . showValue <$>+                 (args !? #score_index :: Maybe Int),+               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),+               ("force_suppress",) . showValue <$>+                 (args !? #force_suppress :: Maybe Bool),+               ("in_format",) . showValue <$>+                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),+               ("out_format",) . showValue <$>+                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_box_nms"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_box_iou(symbol)" =+     '[ '("format", AttrOpt (EnumType '["center", "corner"])),+        '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_contrib_box_iou ::+                 forall args . Fullfilled "_contrib_box_iou(symbol)" args =>+                   String ->+                     ArgsHMap "_contrib_box_iou(symbol)" args -> IO SymbolHandle+_contrib_box_iou name args+  = let scalarArgs+          = catMaybes+              [("format",) . showValue <$>+                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_box_iou"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_contrib_box_iou(symbol)" =+     '[ '("format", AttrOpt (EnumType '["center", "corner"]))]++_backward_contrib_box_iou ::+                          forall args .+                            Fullfilled "_backward_contrib_box_iou(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_contrib_box_iou(symbol)" args ->+                                IO SymbolHandle+_backward_contrib_box_iou name args+  = let scalarArgs+          = catMaybes+              [("format",) . showValue <$>+                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_box_iou"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_bipartite_matching(symbol)" =+     '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float),+        '("topk", AttrOpt Int), '("data", AttrOpt SymbolHandle)]++_contrib_bipartite_matching ::+                            forall args .+                              Fullfilled "_contrib_bipartite_matching(symbol)" args =>+                              String ->+                                ArgsHMap "_contrib_bipartite_matching(symbol)" args ->+                                  IO SymbolHandle+_contrib_bipartite_matching name args+  = let scalarArgs+          = catMaybes+              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_bipartite_matching"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward_contrib_bipartite_matching(symbol)" =+     '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float),+        '("topk", AttrOpt Int)]++_backward_contrib_bipartite_matching ::+                                     forall args .+                                       Fullfilled "_backward_contrib_bipartite_matching(symbol)"+                                         args =>+                                       String ->+                                         ArgsHMap "_backward_contrib_bipartite_matching(symbol)"+                                           args+                                           -> IO SymbolHandle+_backward_contrib_bipartite_matching name args+  = let scalarArgs+          = catMaybes+              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_bipartite_matching"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_BilinearResize2D(symbol)" =+     '[ '("height", AttrReq Int), '("width", AttrReq Int),+        '("data", AttrOpt SymbolHandle)]++_contrib_BilinearResize2D ::+                          forall args .+                            Fullfilled "_contrib_BilinearResize2D(symbol)" args =>+                            String ->+                              ArgsHMap "_contrib_BilinearResize2D(symbol)" args ->+                                IO SymbolHandle+_contrib_BilinearResize2D name args+  = let scalarArgs+          = catMaybes+              [("height",) . showValue <$> (args !? #height :: Maybe Int),+               ("width",) . showValue <$> (args !? #width :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_BilinearResize2D"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward_contrib_BilinearResize2D(symbol)" = '[]++_backward_contrib_BilinearResize2D ::+                                   forall args .+                                     Fullfilled "_backward_contrib_BilinearResize2D(symbol)" args =>+                                     String ->+                                       ArgsHMap "_backward_contrib_BilinearResize2D(symbol)" args ->+                                         IO SymbolHandle+_backward_contrib_BilinearResize2D name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_BilinearResize2D"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_boolean_mask(symbol)" =+     '[ '("axis", AttrOpt Int), '("data", AttrOpt SymbolHandle),+        '("index", AttrOpt SymbolHandle)]++_contrib_boolean_mask ::+                      forall args . Fullfilled "_contrib_boolean_mask(symbol)" args =>+                        String ->+                          ArgsHMap "_contrib_boolean_mask(symbol)" args -> IO SymbolHandle+_contrib_boolean_mask name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("index",) <$> (args !? #index :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_boolean_mask"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward_contrib_boolean_mask(symbol)" =+     '[ '("axis", AttrOpt Int)]++_backward_contrib_boolean_mask ::+                               forall args .+                                 Fullfilled "_backward_contrib_boolean_mask(symbol)" args =>+                                 String ->+                                   ArgsHMap "_backward_contrib_boolean_mask(symbol)" args ->+                                     IO SymbolHandle+_backward_contrib_boolean_mask name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_boolean_mask"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_SyncBatchNorm(symbol)" =+     '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float),+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),+        '("output_mean_var", AttrOpt Bool), '("ndev", AttrOpt Int),+        '("key", AttrOpt String), '("data", AttrOpt SymbolHandle),+        '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle),+        '("moving_mean", AttrOpt SymbolHandle),+        '("moving_var", AttrOpt SymbolHandle)]++_contrib_SyncBatchNorm ::+                       forall args . Fullfilled "_contrib_SyncBatchNorm(symbol)" args =>+                         String ->+                           ArgsHMap "_contrib_SyncBatchNorm(symbol)" args -> IO SymbolHandle+_contrib_SyncBatchNorm name args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool),+               ("ndev",) . showValue <$> (args !? #ndev :: Maybe Int),+               ("key",) . showValue <$> (args !? #key :: Maybe String)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),+               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle),+               ("moving_mean",) <$> (args !? #moving_mean :: Maybe SymbolHandle),+               ("moving_var",) <$> (args !? #moving_var :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_SyncBatchNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_AdaptiveAvgPooling2D(symbol)"+     =+     '[ '("output_size", AttrOpt [Int]),+        '("data", AttrOpt SymbolHandle)]++_contrib_AdaptiveAvgPooling2D ::+                              forall args .+                                Fullfilled "_contrib_AdaptiveAvgPooling2D(symbol)" args =>+                                String ->+                                  ArgsHMap "_contrib_AdaptiveAvgPooling2D(symbol)" args ->+                                    IO SymbolHandle+_contrib_AdaptiveAvgPooling2D name args+  = let scalarArgs+          = catMaybes+              [("output_size",) . showValue <$>+                 (args !? #output_size :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_AdaptiveAvgPooling2D"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward_contrib_AdaptiveAvgPooling2D(symbol)" =+     '[]++_backward_contrib_AdaptiveAvgPooling2D ::+                                       forall args .+                                         Fullfilled "_backward_contrib_AdaptiveAvgPooling2D(symbol)"+                                           args =>+                                         String ->+                                           ArgsHMap "_backward_contrib_AdaptiveAvgPooling2D(symbol)"+                                             args+                                             -> IO SymbolHandle+_backward_contrib_AdaptiveAvgPooling2D name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_AdaptiveAvgPooling2D"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_to_tensor(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++_image_to_tensor ::+                 forall args . Fullfilled "_image_to_tensor(symbol)" args =>+                   String ->+                     ArgsHMap "_image_to_tensor(symbol)" args -> IO SymbolHandle+_image_to_tensor name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_to_tensor"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_normalize(symbol)" =+     '[ '("mean", AttrReq [Float]), '("std", AttrReq [Float]),+        '("data", AttrOpt SymbolHandle)]++_image_normalize ::+                 forall args . Fullfilled "_image_normalize(symbol)" args =>+                   String ->+                     ArgsHMap "_image_normalize(symbol)" args -> IO SymbolHandle+_image_normalize name args+  = let scalarArgs+          = catMaybes+              [("mean",) . showValue <$> (args !? #mean :: Maybe [Float]),+               ("std",) . showValue <$> (args !? #std :: Maybe [Float])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_normalize"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_flip_left_right(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++_image_flip_left_right ::+                       forall args . Fullfilled "_image_flip_left_right(symbol)" args =>+                         String ->+                           ArgsHMap "_image_flip_left_right(symbol)" args -> IO SymbolHandle+_image_flip_left_right name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_flip_left_right"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_random_flip_left_right(symbol)"+     = '[ '("data", AttrOpt SymbolHandle)]++_image_random_flip_left_right ::+                              forall args .+                                Fullfilled "_image_random_flip_left_right(symbol)" args =>+                                String ->+                                  ArgsHMap "_image_random_flip_left_right(symbol)" args ->+                                    IO SymbolHandle+_image_random_flip_left_right name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_flip_left_right"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_flip_top_bottom(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++_image_flip_top_bottom ::+                       forall args . Fullfilled "_image_flip_top_bottom(symbol)" args =>+                         String ->+                           ArgsHMap "_image_flip_top_bottom(symbol)" args -> IO SymbolHandle+_image_flip_top_bottom name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_flip_top_bottom"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_random_flip_top_bottom(symbol)"+     = '[ '("data", AttrOpt SymbolHandle)]++_image_random_flip_top_bottom ::+                              forall args .+                                Fullfilled "_image_random_flip_top_bottom(symbol)" args =>+                                String ->+                                  ArgsHMap "_image_random_flip_top_bottom(symbol)" args ->+                                    IO SymbolHandle+_image_random_flip_top_bottom name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_flip_top_bottom"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_random_brightness(symbol)" =+     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),+        '("data", AttrOpt SymbolHandle)]++_image_random_brightness ::+                         forall args . Fullfilled "_image_random_brightness(symbol)" args =>+                           String ->+                             ArgsHMap "_image_random_brightness(symbol)" args -> IO SymbolHandle+_image_random_brightness name args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_brightness"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_random_contrast(symbol)" =+     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),+        '("data", AttrOpt SymbolHandle)]++_image_random_contrast ::+                       forall args . Fullfilled "_image_random_contrast(symbol)" args =>+                         String ->+                           ArgsHMap "_image_random_contrast(symbol)" args -> IO SymbolHandle+_image_random_contrast name args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_contrast"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_random_saturation(symbol)" =+     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),+        '("data", AttrOpt SymbolHandle)]++_image_random_saturation ::+                         forall args . Fullfilled "_image_random_saturation(symbol)" args =>+                           String ->+                             ArgsHMap "_image_random_saturation(symbol)" args -> IO SymbolHandle+_image_random_saturation name args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_saturation"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_random_hue(symbol)" =+     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),+        '("data", AttrOpt SymbolHandle)]++_image_random_hue ::+                  forall args . Fullfilled "_image_random_hue(symbol)" args =>+                    String ->+                      ArgsHMap "_image_random_hue(symbol)" args -> IO SymbolHandle+_image_random_hue name args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_hue"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_random_color_jitter(symbol)" =+     '[ '("brightness", AttrReq Float), '("contrast", AttrReq Float),+        '("saturation", AttrReq Float), '("hue", AttrReq Float),+        '("data", AttrOpt SymbolHandle)]++_image_random_color_jitter ::+                           forall args .+                             Fullfilled "_image_random_color_jitter(symbol)" args =>+                             String ->+                               ArgsHMap "_image_random_color_jitter(symbol)" args ->+                                 IO SymbolHandle+_image_random_color_jitter name args+  = let scalarArgs+          = catMaybes+              [("brightness",) . showValue <$>+                 (args !? #brightness :: Maybe Float),+               ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float),+               ("saturation",) . showValue <$>+                 (args !? #saturation :: Maybe Float),+               ("hue",) . showValue <$> (args !? #hue :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_color_jitter"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_adjust_lighting(symbol)" =+     '[ '("alpha", AttrReq [Float]), '("data", AttrOpt SymbolHandle)]++_image_adjust_lighting ::+                       forall args . Fullfilled "_image_adjust_lighting(symbol)" args =>+                         String ->+                           ArgsHMap "_image_adjust_lighting(symbol)" args -> IO SymbolHandle+_image_adjust_lighting name args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe [Float])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_adjust_lighting"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_random_lighting(symbol)" =+     '[ '("alpha_std", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_image_random_lighting ::+                       forall args . Fullfilled "_image_random_lighting(symbol)" args =>+                         String ->+                           ArgsHMap "_image_random_lighting(symbol)" args -> IO SymbolHandle+_image_random_lighting name args+  = let scalarArgs+          = catMaybes+              [("alpha_std",) . showValue <$>+                 (args !? #alpha_std :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_lighting"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "softmax(symbol)" =+     '[ '("axis", AttrOpt Int),+        '("temperature", AttrOpt (Maybe Double)),+        '("data", AttrOpt SymbolHandle)]++softmax ::+        forall args . Fullfilled "softmax(symbol)" args =>+          String -> ArgsHMap "softmax(symbol)" args -> IO SymbolHandle+softmax name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("temperature",) . showValue <$>+                 (args !? #temperature :: Maybe (Maybe Double))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softmax"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_softmax(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_softmax ::+                  forall args . Fullfilled "_backward_softmax(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_softmax(symbol)" args -> IO SymbolHandle+_backward_softmax name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_softmax"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "softmin(symbol)" =+     '[ '("axis", AttrOpt Int),+        '("temperature", AttrOpt (Maybe Double)),+        '("data", AttrOpt SymbolHandle)]++softmin ::+        forall args . Fullfilled "softmin(symbol)" args =>+          String -> ArgsHMap "softmin(symbol)" args -> IO SymbolHandle+softmin name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("temperature",) . showValue <$>+                 (args !? #temperature :: Maybe (Maybe Double))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softmin"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_softmin(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_softmin ::+                  forall args . Fullfilled "_backward_softmin(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_softmin(symbol)" args -> IO SymbolHandle+_backward_softmin name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_softmin"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "log_softmax(symbol)" =+     '[ '("axis", AttrOpt Int),+        '("temperature", AttrOpt (Maybe Double)),+        '("data", AttrOpt SymbolHandle)]++log_softmax ::+            forall args . Fullfilled "log_softmax(symbol)" args =>+              String -> ArgsHMap "log_softmax(symbol)" args -> IO SymbolHandle+log_softmax name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("temperature",) . showValue <$>+                 (args !? #temperature :: Maybe (Maybe Double))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log_softmax"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_log_softmax(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_log_softmax ::+                      forall args . Fullfilled "_backward_log_softmax(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_log_softmax(symbol)" args -> IO SymbolHandle+_backward_log_softmax name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log_softmax"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Pooling(symbol)" =+     '[ '("kernel", AttrOpt [Int]),+        '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])),+        '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool),+        '("pooling_convention",+          AttrOpt (EnumType '["full", "same", "valid"])),+        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("p_value", AttrOpt (Maybe Int)),+        '("count_include_pad", AttrOpt (Maybe Bool)),+        '("data", AttrOpt SymbolHandle)]++_Pooling ::+         forall args . Fullfilled "_Pooling(symbol)" args =>+           String -> ArgsHMap "_Pooling(symbol)" args -> IO SymbolHandle+_Pooling name args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("pool_type",) . showValue <$>+                 (args !? #pool_type ::+                    Maybe (EnumType '["avg", "lp", "max", "sum"])),+               ("global_pool",) . showValue <$>+                 (args !? #global_pool :: Maybe Bool),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("pooling_convention",) . showValue <$>+                 (args !? #pooling_convention ::+                    Maybe (EnumType '["full", "same", "valid"])),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("p_value",) . showValue <$>+                 (args !? #p_value :: Maybe (Maybe Int)),+               ("count_include_pad",) . showValue <$>+                 (args !? #count_include_pad :: Maybe (Maybe Bool))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Pooling(symbol)" = '[]++_backward_Pooling ::+                  forall args . Fullfilled "_backward_Pooling(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_Pooling(symbol)" args -> IO SymbolHandle+_backward_Pooling name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Deconvolution(symbol)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("adj", AttrOpt [Int]), '("target_shape", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("cudnn_tune",+          AttrOpt+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+        '("cudnn_off", AttrOpt Bool),+        '("layout",+          AttrOpt+            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),+        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),+        '("bias", AttrOpt SymbolHandle)]++_Deconvolution ::+               forall args . Fullfilled "_Deconvolution(symbol)" args =>+                 String -> ArgsHMap "_Deconvolution(symbol)" args -> IO SymbolHandle+_Deconvolution name args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Deconvolution"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Deconvolution(symbol)" = '[]++_backward_Deconvolution ::+                        forall args . Fullfilled "_backward_Deconvolution(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_Deconvolution(symbol)" args -> IO SymbolHandle+_backward_Deconvolution name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Deconvolution"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Activation(symbol)" =+     '[ '("act_type",+          AttrReq+            (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"])),+        '("data", AttrOpt SymbolHandle)]++_Activation ::+            forall args . Fullfilled "_Activation(symbol)" args =>+              String -> ArgsHMap "_Activation(symbol)" args -> IO SymbolHandle+_Activation name args+  = let scalarArgs+          = catMaybes+              [("act_type",) . showValue <$>+                 (args !? #act_type ::+                    Maybe+                      (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Activation"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Activation(symbol)" = '[]++_backward_Activation ::+                     forall args . Fullfilled "_backward_Activation(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_Activation(symbol)" args -> IO SymbolHandle+_backward_Activation name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Activation"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_UpSampling(symbol)" =+     '[ '("scale", AttrReq Int), '("num_filter", AttrOpt Int),+        '("sample_type", AttrReq (EnumType '["bilinear", "nearest"])),+        '("multi_input_mode", AttrOpt (EnumType '["concat", "sum"])),+        '("num_args", AttrReq Int), '("workspace", AttrOpt Int),+        '("data", AttrOpt [SymbolHandle])]++_UpSampling ::+            forall args . Fullfilled "_UpSampling(symbol)" args =>+              String -> ArgsHMap "_UpSampling(symbol)" args -> IO SymbolHandle+_UpSampling name args+  = let scalarArgs+          = catMaybes+              [("scale",) . showValue <$> (args !? #scale :: Maybe Int),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("sample_type",) . showValue <$>+                 (args !? #sample_type ::+                    Maybe (EnumType '["bilinear", "nearest"])),+               ("multi_input_mode",) . showValue <$>+                 (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])),+               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "UpSampling"+         sym <- if hasKey args #num_args then+                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals+                  else+                  mxSymbolCreateAtomicSymbol (fromOpHandle op)+                    ("num_args" : scalarkeys)+                    (showValue (length array) : scalarvals)+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_backward_UpSampling(symbol)" = '[]++_backward_UpSampling ::+                     forall args . Fullfilled "_backward_UpSampling(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_UpSampling(symbol)" args -> IO SymbolHandle+_backward_UpSampling name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_UpSampling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_BatchNorm(symbol)" =+     '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float),+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),+        '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int),+        '("cudnn_off", AttrOpt Bool), '("data", AttrOpt SymbolHandle),+        '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle),+        '("moving_mean", AttrOpt SymbolHandle),+        '("moving_var", AttrOpt SymbolHandle)]++_BatchNorm ::+           forall args . Fullfilled "_BatchNorm(symbol)" args =>+             String -> ArgsHMap "_BatchNorm(symbol)" args -> IO SymbolHandle+_BatchNorm name args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),+               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle),+               ("moving_mean",) <$> (args !? #moving_mean :: Maybe SymbolHandle),+               ("moving_var",) <$> (args !? #moving_var :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BatchNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_BatchNorm(symbol)" = '[]++_backward_BatchNorm ::+                    forall args . Fullfilled "_backward_BatchNorm(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_BatchNorm(symbol)" args -> IO SymbolHandle+_backward_BatchNorm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BatchNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_CTCLoss(symbol)" =+     '[ '("use_data_lengths", AttrOpt Bool),+        '("use_label_lengths", AttrOpt Bool),+        '("blank_label", AttrOpt (EnumType '["first", "last"])),+        '("data", AttrOpt SymbolHandle), '("label", AttrOpt SymbolHandle),+        '("data_lengths", AttrOpt SymbolHandle),+        '("label_lengths", AttrOpt SymbolHandle)]++_CTCLoss ::+         forall args . Fullfilled "_CTCLoss(symbol)" args =>+           String -> ArgsHMap "_CTCLoss(symbol)" args -> IO SymbolHandle+_CTCLoss name args+  = let scalarArgs+          = catMaybes+              [("use_data_lengths",) . showValue <$>+                 (args !? #use_data_lengths :: Maybe Bool),+               ("use_label_lengths",) . showValue <$>+                 (args !? #use_label_lengths :: Maybe Bool),+               ("blank_label",) . showValue <$>+                 (args !? #blank_label :: Maybe (EnumType '["first", "last"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle),+               ("data_lengths",) <$>+                 (args !? #data_lengths :: Maybe SymbolHandle),+               ("label_lengths",) <$>+                 (args !? #label_lengths :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "CTCLoss"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_ctc_loss(symbol)" = '[]++_backward_ctc_loss ::+                   forall args . Fullfilled "_backward_ctc_loss(symbol)" args =>+                     String ->+                       ArgsHMap "_backward_ctc_loss(symbol)" args -> IO SymbolHandle+_backward_ctc_loss name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_ctc_loss"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_FullyConnected(symbol)" =+     '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool),+        '("flatten", AttrOpt Bool), '("data", AttrOpt SymbolHandle),+        '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle)]++_FullyConnected ::+                forall args . Fullfilled "_FullyConnected(symbol)" args =>+                  String ->+                    ArgsHMap "_FullyConnected(symbol)" args -> IO SymbolHandle+_FullyConnected name args+  = let scalarArgs+          = catMaybes+              [("num_hidden",) . showValue <$>+                 (args !? #num_hidden :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "FullyConnected"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_FullyConnected(symbol)" =+     '[]++_backward_FullyConnected ::+                         forall args . Fullfilled "_backward_FullyConnected(symbol)" args =>+                           String ->+                             ArgsHMap "_backward_FullyConnected(symbol)" args -> IO SymbolHandle+_backward_FullyConnected name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_FullyConnected"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Convolution(symbol)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("cudnn_tune",+          AttrOpt+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+        '("cudnn_off", AttrOpt Bool),+        '("layout",+          AttrOpt+            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),+        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),+        '("bias", AttrOpt SymbolHandle)]++_Convolution ::+             forall args . Fullfilled "_Convolution(symbol)" args =>+               String -> ArgsHMap "_Convolution(symbol)" args -> IO SymbolHandle+_Convolution name args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Convolution"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Convolution(symbol)" = '[]++_backward_Convolution ::+                      forall args . Fullfilled "_backward_Convolution(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_Convolution(symbol)" args -> IO SymbolHandle+_backward_Convolution name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Convolution"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_LayerNorm(symbol)" =+     '[ '("axis", AttrOpt Int), '("eps", AttrOpt Float),+        '("output_mean_var", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle), '("gamma", AttrOpt SymbolHandle),+        '("beta", AttrOpt SymbolHandle)]++_LayerNorm ::+           forall args . Fullfilled "_LayerNorm(symbol)" args =>+             String -> ArgsHMap "_LayerNorm(symbol)" args -> IO SymbolHandle+_LayerNorm name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),+               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LayerNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_LayerNorm(symbol)" = '[]++_backward_LayerNorm ::+                    forall args . Fullfilled "_backward_LayerNorm(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_LayerNorm(symbol)" args -> IO SymbolHandle+_backward_LayerNorm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LayerNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Concat(symbol)" =+     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),+        '("data", AttrOpt [SymbolHandle])]++_Concat ::+        forall args . Fullfilled "_Concat(symbol)" args =>+          String -> ArgsHMap "_Concat(symbol)" args -> IO SymbolHandle+_Concat name args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "Concat"+         sym <- if hasKey args #num_args then+                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals+                  else+                  mxSymbolCreateAtomicSymbol (fromOpHandle op)+                    ("num_args" : scalarkeys)+                    (showValue (length array) : scalarvals)+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_backward_Concat(symbol)" = '[]++_backward_Concat ::+                 forall args . Fullfilled "_backward_Concat(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_Concat(symbol)" args -> IO SymbolHandle+_backward_Concat name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Concat"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_rnn_param_concat(symbol)" =+     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),+        '("data", AttrOpt [SymbolHandle])]++_rnn_param_concat ::+                  forall args . Fullfilled "_rnn_param_concat(symbol)" args =>+                    String ->+                      ArgsHMap "_rnn_param_concat(symbol)" args -> IO SymbolHandle+_rnn_param_concat name args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "_rnn_param_concat"+         sym <- if hasKey args #num_args then+                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals+                  else+                  mxSymbolCreateAtomicSymbol (fromOpHandle op)+                    ("num_args" : scalarkeys)+                    (showValue (length array) : scalarvals)+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_SoftmaxActivation(symbol)" =+     '[ '("mode", AttrOpt (EnumType '["channel", "instance"])),+        '("data", AttrOpt SymbolHandle)]++_SoftmaxActivation ::+                   forall args . Fullfilled "_SoftmaxActivation(symbol)" args =>+                     String ->+                       ArgsHMap "_SoftmaxActivation(symbol)" args -> IO SymbolHandle+_SoftmaxActivation name args+  = let scalarArgs+          = catMaybes+              [("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["channel", "instance"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SoftmaxActivation"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SoftmaxActivation(symbol)" =+     '[]++_backward_SoftmaxActivation ::+                            forall args .+                              Fullfilled "_backward_SoftmaxActivation(symbol)" args =>+                              String ->+                                ArgsHMap "_backward_SoftmaxActivation(symbol)" args ->+                                  IO SymbolHandle+_backward_SoftmaxActivation name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SoftmaxActivation"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_LRN(symbol)" =+     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),+        '("knorm", AttrOpt Float), '("nsize", AttrReq Int),+        '("data", AttrOpt SymbolHandle)]++_LRN ::+     forall args . Fullfilled "_LRN(symbol)" args =>+       String -> ArgsHMap "_LRN(symbol)" args -> IO SymbolHandle+_LRN name args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float),+               ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LRN"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_LRN(symbol)" = '[]++_backward_LRN ::+              forall args . Fullfilled "_backward_LRN(symbol)" args =>+                String -> ArgsHMap "_backward_LRN(symbol)" args -> IO SymbolHandle+_backward_LRN name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LRN"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Dropout(symbol)" =+     '[ '("p", AttrOpt Float),+        '("mode", AttrOpt (EnumType '["always", "training"])),+        '("axes", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]++_Dropout ::+         forall args . Fullfilled "_Dropout(symbol)" args =>+           String -> ArgsHMap "_Dropout(symbol)" args -> IO SymbolHandle+_Dropout name args+  = let scalarArgs+          = catMaybes+              [("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["always", "training"])),+               ("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Dropout"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Dropout(symbol)" = '[]++_backward_Dropout ::+                  forall args . Fullfilled "_backward_Dropout(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_Dropout(symbol)" args -> IO SymbolHandle+_backward_Dropout name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Dropout"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_dequantize(symbol)" =+     '[ '("out_type", AttrOpt (EnumType '["float32"])),+        '("data", AttrOpt SymbolHandle),+        '("min_range", AttrOpt SymbolHandle),+        '("max_range", AttrOpt SymbolHandle)]++_contrib_dequantize ::+                    forall args . Fullfilled "_contrib_dequantize(symbol)" args =>+                      String ->+                        ArgsHMap "_contrib_dequantize(symbol)" args -> IO SymbolHandle+_contrib_dequantize name args+  = let scalarArgs+          = catMaybes+              [("out_type",) . showValue <$>+                 (args !? #out_type :: Maybe (EnumType '["float32"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle),+               ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_dequantize"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_quantized_flatten(symbol)" =+     '[ '("data", AttrOpt SymbolHandle),+        '("min_data", AttrOpt SymbolHandle),+        '("max_data", AttrOpt SymbolHandle)]++_contrib_quantized_flatten ::+                           forall args .+                             Fullfilled "_contrib_quantized_flatten(symbol)" args =>+                             String ->+                               ArgsHMap "_contrib_quantized_flatten(symbol)" args ->+                                 IO SymbolHandle+_contrib_quantized_flatten name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_flatten"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_quantized_conv(symbol)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("cudnn_tune",+          AttrOpt+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+        '("cudnn_off", AttrOpt Bool),+        '("layout",+          AttrOpt+            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),+        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),+        '("bias", AttrOpt SymbolHandle),+        '("min_data", AttrOpt SymbolHandle),+        '("max_data", AttrOpt SymbolHandle),+        '("min_weight", AttrOpt SymbolHandle),+        '("max_weight", AttrOpt SymbolHandle),+        '("min_bias", AttrOpt SymbolHandle),+        '("max_bias", AttrOpt SymbolHandle)]++_contrib_quantized_conv ::+                        forall args . Fullfilled "_contrib_quantized_conv(symbol)" args =>+                          String ->+                            ArgsHMap "_contrib_quantized_conv(symbol)" args -> IO SymbolHandle+_contrib_quantized_conv name args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle),+               ("min_weight",) <$> (args !? #min_weight :: Maybe SymbolHandle),+               ("max_weight",) <$> (args !? #max_weight :: Maybe SymbolHandle),+               ("min_bias",) <$> (args !? #min_bias :: Maybe SymbolHandle),+               ("max_bias",) <$> (args !? #max_bias :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_conv"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_contrib_quantized_fully_connected(symbol)" =+     '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool),+        '("flatten", AttrOpt Bool), '("data", AttrOpt SymbolHandle),+        '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle),+        '("min_data", AttrOpt SymbolHandle),+        '("max_data", AttrOpt SymbolHandle),+        '("min_weight", AttrOpt SymbolHandle),+        '("max_weight", AttrOpt SymbolHandle),+        '("min_bias", AttrOpt SymbolHandle),+        '("max_bias", AttrOpt SymbolHandle)]++_contrib_quantized_fully_connected ::+                                   forall args .+                                     Fullfilled "_contrib_quantized_fully_connected(symbol)" args =>+                                     String ->+                                       ArgsHMap "_contrib_quantized_fully_connected(symbol)" args ->+                                         IO SymbolHandle+_contrib_quantized_fully_connected name args+  = let scalarArgs+          = catMaybes+              [("num_hidden",) . showValue <$>+                 (args !? #num_hidden :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle),+               ("min_weight",) <$> (args !? #min_weight :: Maybe SymbolHandle),+               ("max_weight",) <$> (args !? #max_weight :: Maybe SymbolHandle),+               ("min_bias",) <$> (args !? #min_bias :: Maybe SymbolHandle),+               ("max_bias",) <$> (args !? #max_bias :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_fully_connected"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_quantized_pooling(symbol)" =+     '[ '("kernel", AttrOpt [Int]),+        '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])),+        '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool),+        '("pooling_convention",+          AttrOpt (EnumType '["full", "same", "valid"])),+        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("p_value", AttrOpt (Maybe Int)),+        '("count_include_pad", AttrOpt (Maybe Bool)),+        '("data", AttrOpt SymbolHandle),+        '("min_data", AttrOpt SymbolHandle),+        '("max_data", AttrOpt SymbolHandle)]++_contrib_quantized_pooling ::+                           forall args .+                             Fullfilled "_contrib_quantized_pooling(symbol)" args =>+                             String ->+                               ArgsHMap "_contrib_quantized_pooling(symbol)" args ->+                                 IO SymbolHandle+_contrib_quantized_pooling name args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("pool_type",) . showValue <$>+                 (args !? #pool_type ::+                    Maybe (EnumType '["avg", "lp", "max", "sum"])),+               ("global_pool",) . showValue <$>+                 (args !? #global_pool :: Maybe Bool),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("pooling_convention",) . showValue <$>+                 (args !? #pooling_convention ::+                    Maybe (EnumType '["full", "same", "valid"])),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("p_value",) . showValue <$>+                 (args !? #p_value :: Maybe (Maybe Int)),+               ("count_include_pad",) . showValue <$>+                 (args !? #count_include_pad :: Maybe (Maybe Bool))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_pooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_quantized_concat(symbol)" =+     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),+        '("data", AttrOpt [SymbolHandle])]++_contrib_quantized_concat ::+                          forall args .+                            Fullfilled "_contrib_quantized_concat(symbol)" args =>+                            String ->+                              ArgsHMap "_contrib_quantized_concat(symbol)" args ->+                                IO SymbolHandle+_contrib_quantized_concat name args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "_contrib_quantized_concat"+         sym <- if hasKey args #num_args then+                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals+                  else+                  mxSymbolCreateAtomicSymbol (fromOpHandle op)+                    ("num_args" : scalarkeys)+                    (showValue (length array) : scalarvals)+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_contrib_requantize(symbol)" =+     '[ '("min_calib_range", AttrOpt (Maybe Float)),+        '("max_calib_range", AttrOpt (Maybe Float)),+        '("data", AttrOpt SymbolHandle),+        '("min_range", AttrOpt SymbolHandle),+        '("max_range", AttrOpt SymbolHandle)]++_contrib_requantize ::+                    forall args . Fullfilled "_contrib_requantize(symbol)" args =>+                      String ->+                        ArgsHMap "_contrib_requantize(symbol)" args -> IO SymbolHandle+_contrib_requantize name args+  = let scalarArgs+          = catMaybes+              [("min_calib_range",) . showValue <$>+                 (args !? #min_calib_range :: Maybe (Maybe Float)),+               ("max_calib_range",) . showValue <$>+                 (args !? #max_calib_range :: Maybe (Maybe Float))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle),+               ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_requantize"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_quantize(symbol)" =+     '[ '("out_type", AttrOpt (EnumType '["int8", "uint8"])),+        '("data", AttrOpt SymbolHandle),+        '("min_range", AttrOpt SymbolHandle),+        '("max_range", AttrOpt SymbolHandle)]++_contrib_quantize ::+                  forall args . Fullfilled "_contrib_quantize(symbol)" args =>+                    String ->+                      ArgsHMap "_contrib_quantize(symbol)" args -> IO SymbolHandle+_contrib_quantize name args+  = let scalarArgs+          = catMaybes+              [("out_type",) . showValue <$>+                 (args !? #out_type :: Maybe (EnumType '["int8", "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle),+               ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantize"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_cvimread(symbol)" =+     '[ '("filename", AttrReq String), '("flag", AttrOpt Int),+        '("to_rgb", AttrOpt Bool)]++_cvimread ::+          forall args . Fullfilled "_cvimread(symbol)" args =>+            String -> ArgsHMap "_cvimread(symbol)" args -> IO SymbolHandle+_cvimread name args+  = let scalarArgs+          = catMaybes+              [("filename",) . showValue <$> (args !? #filename :: Maybe String),+               ("flag",) . showValue <$> (args !? #flag :: Maybe Int),+               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_cvimread"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_NoGradient(symbol)" = '[]++_NoGradient ::+            forall args . Fullfilled "_NoGradient(symbol)" args =>+              String -> ArgsHMap "_NoGradient(symbol)" args -> IO SymbolHandle+_NoGradient name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_NoGradient"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_CachedOp(symbol)" =+     '[ '("data", AttrOpt [SymbolHandle])]++_CachedOp ::+          forall args . Fullfilled "_CachedOp(symbol)" args =>+            String -> ArgsHMap "_CachedOp(symbol)" args -> IO SymbolHandle+_CachedOp name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "_CachedOp"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_backward_CachedOp(symbol)" = '[]++_backward_CachedOp ::+                   forall args . Fullfilled "_backward_CachedOp(symbol)" args =>+                     String ->+                       ArgsHMap "_backward_CachedOp(symbol)" args -> IO SymbolHandle+_backward_CachedOp name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_CachedOp"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "softmax_cross_entropy(symbol)" =+     '[ '("data", AttrOpt SymbolHandle),+        '("label", AttrOpt SymbolHandle)]++softmax_cross_entropy ::+                      forall args . Fullfilled "softmax_cross_entropy(symbol)" args =>+                        String ->+                          ArgsHMap "softmax_cross_entropy(symbol)" args -> IO SymbolHandle+softmax_cross_entropy name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softmax_cross_entropy"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward_softmax_cross_entropy(symbol)" = '[]++_backward_softmax_cross_entropy ::+                                forall args .+                                  Fullfilled "_backward_softmax_cross_entropy(symbol)" args =>+                                  String ->+                                    ArgsHMap "_backward_softmax_cross_entropy(symbol)" args ->+                                      IO SymbolHandle+_backward_softmax_cross_entropy name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_softmax_cross_entropy"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Pad(symbol)" =+     '[ '("mode", AttrReq (EnumType '["constant", "edge", "reflect"])),+        '("pad_width", AttrReq [Int]), '("constant_value", AttrOpt Double),+        '("data", AttrOpt SymbolHandle)]++_Pad ::+     forall args . Fullfilled "_Pad(symbol)" args =>+       String -> ArgsHMap "_Pad(symbol)" args -> IO SymbolHandle+_Pad name args+  = let scalarArgs+          = catMaybes+              [("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["constant", "edge", "reflect"])),+               ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]),+               ("constant_value",) . showValue <$>+                 (args !? #constant_value :: Maybe Double)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pad"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_foreach(symbol)" = '[]++_backward_foreach ::+                  forall args . Fullfilled "_backward_foreach(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_foreach(symbol)" args -> IO SymbolHandle+_backward_foreach name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_foreach"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_while_loop(symbol)" = '[]++_backward_while_loop ::+                     forall args . Fullfilled "_backward_while_loop(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_while_loop(symbol)" args -> IO SymbolHandle+_backward_while_loop name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_while_loop"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_cond(symbol)" = '[]++_backward_cond ::+               forall args . Fullfilled "_backward_cond(symbol)" args =>+                 String -> ArgsHMap "_backward_cond(symbol)" args -> IO SymbolHandle+_backward_cond name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cond"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_LeakyReLU(symbol)" =+     '[ '("act_type",+          AttrOpt (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])),+        '("slope", AttrOpt Float), '("lower_bound", AttrOpt Float),+        '("upper_bound", AttrOpt Float), '("data", AttrOpt SymbolHandle),+        '("gamma", AttrOpt SymbolHandle)]++_LeakyReLU ::+           forall args . Fullfilled "_LeakyReLU(symbol)" args =>+             String -> ArgsHMap "_LeakyReLU(symbol)" args -> IO SymbolHandle+_LeakyReLU name args+  = let scalarArgs+          = catMaybes+              [("act_type",) . showValue <$>+                 (args !? #act_type ::+                    Maybe (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])),+               ("slope",) . showValue <$> (args !? #slope :: Maybe Float),+               ("lower_bound",) . showValue <$>+                 (args !? #lower_bound :: Maybe Float),+               ("upper_bound",) . showValue <$>+                 (args !? #upper_bound :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LeakyReLU"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SwapAxis(symbol)" =+     '[ '("dim1", AttrOpt Int), '("dim2", AttrOpt Int),+        '("data", AttrOpt SymbolHandle)]++_SwapAxis ::+          forall args . Fullfilled "_SwapAxis(symbol)" args =>+            String -> ArgsHMap "_SwapAxis(symbol)" args -> IO SymbolHandle+_SwapAxis name args+  = let scalarArgs+          = catMaybes+              [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int),+               ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SwapAxis"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_IdentityAttachKLSparseReg(symbol)" =+     '[ '("sparseness_target", AttrOpt Float),+        '("penalty", AttrOpt Float), '("momentum", AttrOpt Float),+        '("data", AttrOpt SymbolHandle)]++_IdentityAttachKLSparseReg ::+                           forall args .+                             Fullfilled "_IdentityAttachKLSparseReg(symbol)" args =>+                             String ->+                               ArgsHMap "_IdentityAttachKLSparseReg(symbol)" args ->+                                 IO SymbolHandle+_IdentityAttachKLSparseReg name args+  = let scalarArgs+          = catMaybes+              [("sparseness_target",) . showValue <$>+                 (args !? #sparseness_target :: Maybe Float),+               ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "IdentityAttachKLSparseReg"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SliceChannel(symbol)" =+     '[ '("num_outputs", AttrReq Int), '("axis", AttrOpt Int),+        '("squeeze_axis", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++_SliceChannel ::+              forall args . Fullfilled "_SliceChannel(symbol)" args =>+                String -> ArgsHMap "_SliceChannel(symbol)" args -> IO SymbolHandle+_SliceChannel name args+  = let scalarArgs+          = catMaybes+              [("num_outputs",) . showValue <$>+                 (args !? #num_outputs :: Maybe Int),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("squeeze_axis",) . showValue <$>+                 (args !? #squeeze_axis :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SliceChannel"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_BatchNorm_v1(symbol)" =+     '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float),+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),+        '("output_mean_var", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle), '("gamma", AttrOpt SymbolHandle),+        '("beta", AttrOpt SymbolHandle)]++_BatchNorm_v1 ::+              forall args . Fullfilled "_BatchNorm_v1(symbol)" args =>+                String -> ArgsHMap "_BatchNorm_v1(symbol)" args -> IO SymbolHandle+_BatchNorm_v1 name args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),+               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BatchNorm_v1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "signsgd_update(symbol)" =+     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle)]++signsgd_update ::+               forall args . Fullfilled "signsgd_update(symbol)" args =>+                 String -> ArgsHMap "signsgd_update(symbol)" args -> IO SymbolHandle+signsgd_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "signsgd_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "signum_update(symbol)" =+     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("wd_lh", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("mom", AttrOpt SymbolHandle)]++signum_update ::+              forall args . Fullfilled "signum_update(symbol)" args =>+                String -> ArgsHMap "signum_update(symbol)" args -> IO SymbolHandle+signum_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("wd_lh",) . showValue <$> (args !? #wd_lh :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("mom",) <$> (args !? #mom :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "signum_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sgd_update(symbol)" =+     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle)]++sgd_update ::+           forall args . Fullfilled "sgd_update(symbol)" args =>+             String -> ArgsHMap "sgd_update(symbol)" args -> IO SymbolHandle+sgd_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sgd_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sgd_mom_update(symbol)" =+     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("mom", AttrOpt SymbolHandle)]++sgd_mom_update ::+               forall args . Fullfilled "sgd_mom_update(symbol)" args =>+                 String -> ArgsHMap "sgd_mom_update(symbol)" args -> IO SymbolHandle+sgd_mom_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("mom",) <$> (args !? #mom :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sgd_mom_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "mp_sgd_update(symbol)" =+     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("weight32", AttrOpt SymbolHandle)]++mp_sgd_update ::+              forall args . Fullfilled "mp_sgd_update(symbol)" args =>+                String -> ArgsHMap "mp_sgd_update(symbol)" args -> IO SymbolHandle+mp_sgd_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mp_sgd_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "mp_sgd_mom_update(symbol)" =+     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("mom", AttrOpt SymbolHandle),+        '("weight32", AttrOpt SymbolHandle)]++mp_sgd_mom_update ::+                  forall args . Fullfilled "mp_sgd_mom_update(symbol)" args =>+                    String ->+                      ArgsHMap "mp_sgd_mom_update(symbol)" args -> IO SymbolHandle+mp_sgd_mom_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("mom",) <$> (args !? #mom :: Maybe SymbolHandle),+               ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mp_sgd_mom_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "ftml_update(symbol)" =+     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),+        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Double),+        '("t", AttrReq Int), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float), '("clip_grad", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("d", AttrOpt SymbolHandle), '("v", AttrOpt SymbolHandle),+        '("z", AttrOpt SymbolHandle)]++ftml_update ::+            forall args . Fullfilled "ftml_update(symbol)" args =>+              String -> ArgsHMap "ftml_update(symbol)" args -> IO SymbolHandle+ftml_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Double),+               ("t",) . showValue <$> (args !? #t :: Maybe Int),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_grad",) . showValue <$> (args !? #clip_grad :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("d",) <$> (args !? #d :: Maybe SymbolHandle),+               ("v",) <$> (args !? #v :: Maybe SymbolHandle),+               ("z",) <$> (args !? #z :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ftml_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "adam_update(symbol)" =+     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),+        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("mean", AttrOpt SymbolHandle), '("var", AttrOpt SymbolHandle)]++adam_update ::+            forall args . Fullfilled "adam_update(symbol)" args =>+              String -> ArgsHMap "adam_update(symbol)" args -> IO SymbolHandle+adam_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("mean",) <$> (args !? #mean :: Maybe SymbolHandle),+               ("var",) <$> (args !? #var :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "adam_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "rmsprop_update(symbol)" =+     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),+        '("epsilon", AttrOpt Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("clip_weights", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("n", AttrOpt SymbolHandle)]++rmsprop_update ::+               forall args . Fullfilled "rmsprop_update(symbol)" args =>+                 String -> ArgsHMap "rmsprop_update(symbol)" args -> IO SymbolHandle+rmsprop_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("clip_weights",) . showValue <$>+                 (args !? #clip_weights :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("n",) <$> (args !? #n :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rmsprop_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "rmspropalex_update(symbol)" =+     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),+        '("gamma2", AttrOpt Float), '("epsilon", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("clip_weights", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("n", AttrOpt SymbolHandle), '("g", AttrOpt SymbolHandle),+        '("delta", AttrOpt SymbolHandle)]++rmspropalex_update ::+                   forall args . Fullfilled "rmspropalex_update(symbol)" args =>+                     String ->+                       ArgsHMap "rmspropalex_update(symbol)" args -> IO SymbolHandle+rmspropalex_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),+               ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("clip_weights",) . showValue <$>+                 (args !? #clip_weights :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("n",) <$> (args !? #n :: Maybe SymbolHandle),+               ("g",) <$> (args !? #g :: Maybe SymbolHandle),+               ("delta",) <$> (args !? #delta :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rmspropalex_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "ftrl_update(symbol)" =+     '[ '("lr", AttrReq Float), '("lamda1", AttrOpt Float),+        '("beta", AttrOpt Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("z", AttrOpt SymbolHandle), '("n", AttrOpt SymbolHandle)]++ftrl_update ::+            forall args . Fullfilled "ftrl_update(symbol)" args =>+              String -> ArgsHMap "ftrl_update(symbol)" args -> IO SymbolHandle+ftrl_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("z",) <$> (args !? #z :: Maybe SymbolHandle),+               ("n",) <$> (args !? #n :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ftrl_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sparse_adagrad_update(symbol)" =+     '[ '("lr", AttrReq Float), '("epsilon", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("history", AttrOpt SymbolHandle)]++_sparse_adagrad_update ::+                       forall args . Fullfilled "_sparse_adagrad_update(symbol)" args =>+                         String ->+                           ArgsHMap "_sparse_adagrad_update(symbol)" args -> IO SymbolHandle+_sparse_adagrad_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("history",) <$> (args !? #history :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sparse_adagrad_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_LinearRegressionOutput(symbol)" =+     '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle),+        '("label", AttrOpt SymbolHandle)]++_LinearRegressionOutput ::+                        forall args . Fullfilled "_LinearRegressionOutput(symbol)" args =>+                          String ->+                            ArgsHMap "_LinearRegressionOutput(symbol)" args -> IO SymbolHandle+_LinearRegressionOutput name args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LinearRegressionOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linear_reg_out(symbol)" =+     '[]++_backward_linear_reg_out ::+                         forall args . Fullfilled "_backward_linear_reg_out(symbol)" args =>+                           String ->+                             ArgsHMap "_backward_linear_reg_out(symbol)" args -> IO SymbolHandle+_backward_linear_reg_out name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linear_reg_out"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_MAERegressionOutput(symbol)" =+     '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle),+        '("label", AttrOpt SymbolHandle)]++_MAERegressionOutput ::+                     forall args . Fullfilled "_MAERegressionOutput(symbol)" args =>+                       String ->+                         ArgsHMap "_MAERegressionOutput(symbol)" args -> IO SymbolHandle+_MAERegressionOutput name args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "MAERegressionOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_mae_reg_out(symbol)" = '[]++_backward_mae_reg_out ::+                      forall args . Fullfilled "_backward_mae_reg_out(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_mae_reg_out(symbol)" args -> IO SymbolHandle+_backward_mae_reg_out name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mae_reg_out"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_LogisticRegressionOutput(symbol)" =+     '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle),+        '("label", AttrOpt SymbolHandle)]++_LogisticRegressionOutput ::+                          forall args .+                            Fullfilled "_LogisticRegressionOutput(symbol)" args =>+                            String ->+                              ArgsHMap "_LogisticRegressionOutput(symbol)" args ->+                                IO SymbolHandle+_LogisticRegressionOutput name args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LogisticRegressionOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_logistic_reg_out(symbol)" =+     '[]++_backward_logistic_reg_out ::+                           forall args .+                             Fullfilled "_backward_logistic_reg_out(symbol)" args =>+                             String ->+                               ArgsHMap "_backward_logistic_reg_out(symbol)" args ->+                                 IO SymbolHandle+_backward_logistic_reg_out name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_logistic_reg_out"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_CustomFunction(symbol)" = '[]++_CustomFunction ::+                forall args . Fullfilled "_CustomFunction(symbol)" args =>+                  String ->+                    ArgsHMap "_CustomFunction(symbol)" args -> IO SymbolHandle+_CustomFunction name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_CustomFunction"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_CustomFunction(symbol)" =+     '[]++_backward_CustomFunction ::+                         forall args . Fullfilled "_backward_CustomFunction(symbol)" args =>+                           String ->+                             ArgsHMap "_backward_CustomFunction(symbol)" args -> IO SymbolHandle+_backward_CustomFunction name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_CustomFunction"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward__Native(symbol)" = '[]++_backward__Native ::+                  forall args . Fullfilled "_backward__Native(symbol)" args =>+                    String ->+                      ArgsHMap "_backward__Native(symbol)" args -> IO SymbolHandle+_backward__Native name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__Native"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward__NDArray(symbol)" = '[]++_backward__NDArray ::+                   forall args . Fullfilled "_backward__NDArray(symbol)" args =>+                     String ->+                       ArgsHMap "_backward__NDArray(symbol)" args -> IO SymbolHandle+_backward__NDArray name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__NDArray"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_MultiBoxTarget(symbol)" =+     '[ '("overlap_threshold", AttrOpt Float),+        '("ignore_label", AttrOpt Float),+        '("negative_mining_ratio", AttrOpt Float),+        '("negative_mining_thresh", AttrOpt Float),+        '("minimum_negative_samples", AttrOpt Int),+        '("variances", AttrOpt [Float]), '("anchor", AttrOpt SymbolHandle),+        '("label", AttrOpt SymbolHandle),+        '("cls_pred", AttrOpt SymbolHandle)]++_contrib_MultiBoxTarget ::+                        forall args . Fullfilled "_contrib_MultiBoxTarget(symbol)" args =>+                          String ->+                            ArgsHMap "_contrib_MultiBoxTarget(symbol)" args -> IO SymbolHandle+_contrib_MultiBoxTarget name args+  = let scalarArgs+          = catMaybes+              [("overlap_threshold",) . showValue <$>+                 (args !? #overlap_threshold :: Maybe Float),+               ("ignore_label",) . showValue <$>+                 (args !? #ignore_label :: Maybe Float),+               ("negative_mining_ratio",) . showValue <$>+                 (args !? #negative_mining_ratio :: Maybe Float),+               ("negative_mining_thresh",) . showValue <$>+                 (args !? #negative_mining_thresh :: Maybe Float),+               ("minimum_negative_samples",) . showValue <$>+                 (args !? #minimum_negative_samples :: Maybe Int),+               ("variances",) . showValue <$>+                 (args !? #variances :: Maybe [Float])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("anchor",) <$> (args !? #anchor :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle),+               ("cls_pred",) <$> (args !? #cls_pred :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxTarget"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_MultiBoxTarget(symbol)" = '[]++_backward__contrib_MultiBoxTarget ::+                                  forall args .+                                    Fullfilled "_backward__contrib_MultiBoxTarget(symbol)" args =>+                                    String ->+                                      ArgsHMap "_backward__contrib_MultiBoxTarget(symbol)" args ->+                                        IO SymbolHandle+_backward__contrib_MultiBoxTarget name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_Proposal(symbol)" =+     '[ '("rpn_pre_nms_top_n", AttrOpt Int),+        '("rpn_post_nms_top_n", AttrOpt Int),+        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),+        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),+        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),+        '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt SymbolHandle),+        '("bbox_pred", AttrOpt SymbolHandle),+        '("im_info", AttrOpt SymbolHandle)]++_contrib_Proposal ::+                  forall args . Fullfilled "_contrib_Proposal(symbol)" args =>+                    String ->+                      ArgsHMap "_contrib_Proposal(symbol)" args -> IO SymbolHandle+_contrib_Proposal name args+  = let scalarArgs+          = catMaybes+              [("rpn_pre_nms_top_n",) . showValue <$>+                 (args !? #rpn_pre_nms_top_n :: Maybe Int),+               ("rpn_post_nms_top_n",) . showValue <$>+                 (args !? #rpn_post_nms_top_n :: Maybe Int),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("rpn_min_size",) . showValue <$>+                 (args !? #rpn_min_size :: Maybe Int),+               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("feature_stride",) . showValue <$>+                 (args !? #feature_stride :: Maybe Int),+               ("output_score",) . showValue <$>+                 (args !? #output_score :: Maybe Bool),+               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle),+               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe SymbolHandle),+               ("im_info",) <$> (args !? #im_info :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_Proposal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward__contrib_Proposal(symbol)" =+     '[]++_backward__contrib_Proposal ::+                            forall args .+                              Fullfilled "_backward__contrib_Proposal(symbol)" args =>+                              String ->+                                ArgsHMap "_backward__contrib_Proposal(symbol)" args ->+                                  IO SymbolHandle+_backward__contrib_Proposal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_Proposal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_count_sketch(symbol)" =+     '[ '("out_dim", AttrReq Int),+        '("processing_batch_size", AttrOpt Int),+        '("data", AttrOpt SymbolHandle), '("h", AttrOpt SymbolHandle),+        '("s", AttrOpt SymbolHandle)]++_contrib_count_sketch ::+                      forall args . Fullfilled "_contrib_count_sketch(symbol)" args =>+                        String ->+                          ArgsHMap "_contrib_count_sketch(symbol)" args -> IO SymbolHandle+_contrib_count_sketch name args+  = let scalarArgs+          = catMaybes+              [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int),+               ("processing_batch_size",) . showValue <$>+                 (args !? #processing_batch_size :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("h",) <$> (args !? #h :: Maybe SymbolHandle),+               ("s",) <$> (args !? #s :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_count_sketch"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_count_sketch(symbol)" = '[]++_backward__contrib_count_sketch ::+                                forall args .+                                  Fullfilled "_backward__contrib_count_sketch(symbol)" args =>+                                  String ->+                                    ArgsHMap "_backward__contrib_count_sketch(symbol)" args ->+                                      IO SymbolHandle+_backward__contrib_count_sketch name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_count_sketch"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_MultiBoxDetection(symbol)" =+     '[ '("clip", AttrOpt Bool), '("threshold", AttrOpt Float),+        '("background_id", AttrOpt Int), '("nms_threshold", AttrOpt Float),+        '("force_suppress", AttrOpt Bool), '("variances", AttrOpt [Float]),+        '("nms_topk", AttrOpt Int), '("cls_prob", AttrOpt SymbolHandle),+        '("loc_pred", AttrOpt SymbolHandle),+        '("anchor", AttrOpt SymbolHandle)]++_contrib_MultiBoxDetection ::+                           forall args .+                             Fullfilled "_contrib_MultiBoxDetection(symbol)" args =>+                             String ->+                               ArgsHMap "_contrib_MultiBoxDetection(symbol)" args ->+                                 IO SymbolHandle+_contrib_MultiBoxDetection name args+  = let scalarArgs+          = catMaybes+              [("clip",) . showValue <$> (args !? #clip :: Maybe Bool),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("background_id",) . showValue <$>+                 (args !? #background_id :: Maybe Int),+               ("nms_threshold",) . showValue <$>+                 (args !? #nms_threshold :: Maybe Float),+               ("force_suppress",) . showValue <$>+                 (args !? #force_suppress :: Maybe Bool),+               ("variances",) . showValue <$>+                 (args !? #variances :: Maybe [Float]),+               ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle),+               ("loc_pred",) <$> (args !? #loc_pred :: Maybe SymbolHandle),+               ("anchor",) <$> (args !? #anchor :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxDetection"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_MultiBoxDetection(symbol)" = '[]++_backward__contrib_MultiBoxDetection ::+                                     forall args .+                                       Fullfilled "_backward__contrib_MultiBoxDetection(symbol)"+                                         args =>+                                       String ->+                                         ArgsHMap "_backward__contrib_MultiBoxDetection(symbol)"+                                           args+                                           -> IO SymbolHandle+_backward__contrib_MultiBoxDetection name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_contrib_DeformablePSROIPooling(symbol)" =+     '[ '("spatial_scale", AttrReq Float), '("output_dim", AttrReq Int),+        '("group_size", AttrReq Int), '("pooled_size", AttrReq Int),+        '("part_size", AttrOpt Int), '("sample_per_part", AttrOpt Int),+        '("trans_std", AttrOpt Float), '("no_trans", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle),+        '("trans", AttrOpt SymbolHandle)]++_contrib_DeformablePSROIPooling ::+                                forall args .+                                  Fullfilled "_contrib_DeformablePSROIPooling(symbol)" args =>+                                  String ->+                                    ArgsHMap "_contrib_DeformablePSROIPooling(symbol)" args ->+                                      IO SymbolHandle+_contrib_DeformablePSROIPooling name args+  = let scalarArgs+          = catMaybes+              [("spatial_scale",) . showValue <$>+                 (args !? #spatial_scale :: Maybe Float),+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),+               ("group_size",) . showValue <$> (args !? #group_size :: Maybe Int),+               ("pooled_size",) . showValue <$>+                 (args !? #pooled_size :: Maybe Int),+               ("part_size",) . showValue <$> (args !? #part_size :: Maybe Int),+               ("sample_per_part",) . showValue <$>+                 (args !? #sample_per_part :: Maybe Int),+               ("trans_std",) . showValue <$> (args !? #trans_std :: Maybe Float),+               ("no_trans",) . showValue <$> (args !? #no_trans :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle),+               ("trans",) <$> (args !? #trans :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_DeformablePSROIPooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_DeformablePSROIPooling(symbol)" =+     '[]++_backward__contrib_DeformablePSROIPooling ::+                                          forall args .+                                            Fullfilled+                                              "_backward__contrib_DeformablePSROIPooling(symbol)"+                                              args =>+                                            String ->+                                              ArgsHMap+                                                "_backward__contrib_DeformablePSROIPooling(symbol)"+                                                args+                                                -> IO SymbolHandle+_backward__contrib_DeformablePSROIPooling name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_fft(symbol)" =+     '[ '("compute_size", AttrOpt Int), '("data", AttrOpt SymbolHandle)]++_contrib_fft ::+             forall args . Fullfilled "_contrib_fft(symbol)" args =>+               String -> ArgsHMap "_contrib_fft(symbol)" args -> IO SymbolHandle+_contrib_fft name args+  = let scalarArgs+          = catMaybes+              [("compute_size",) . showValue <$>+                 (args !? #compute_size :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_fft"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward__contrib_fft(symbol)" = '[]++_backward__contrib_fft ::+                       forall args . Fullfilled "_backward__contrib_fft(symbol)" args =>+                         String ->+                           ArgsHMap "_backward__contrib_fft(symbol)" args -> IO SymbolHandle+_backward__contrib_fft name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_fft"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_MultiBoxPrior(symbol)" =+     '[ '("sizes", AttrOpt [Float]), '("ratios", AttrOpt [Float]),+        '("clip", AttrOpt Bool), '("steps", AttrOpt [Float]),+        '("offsets", AttrOpt [Float]), '("data", AttrOpt SymbolHandle)]++_contrib_MultiBoxPrior ::+                       forall args . Fullfilled "_contrib_MultiBoxPrior(symbol)" args =>+                         String ->+                           ArgsHMap "_contrib_MultiBoxPrior(symbol)" args -> IO SymbolHandle+_contrib_MultiBoxPrior name args+  = let scalarArgs+          = catMaybes+              [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("clip",) . showValue <$> (args !? #clip :: Maybe Bool),+               ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]),+               ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxPrior"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_MultiBoxPrior(symbol)" = '[]++_backward__contrib_MultiBoxPrior ::+                                 forall args .+                                   Fullfilled "_backward__contrib_MultiBoxPrior(symbol)" args =>+                                   String ->+                                     ArgsHMap "_backward__contrib_MultiBoxPrior(symbol)" args ->+                                       IO SymbolHandle+_backward__contrib_MultiBoxPrior name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_MultiProposal(symbol)" =+     '[ '("rpn_pre_nms_top_n", AttrOpt Int),+        '("rpn_post_nms_top_n", AttrOpt Int),+        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),+        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),+        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),+        '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt SymbolHandle),+        '("bbox_pred", AttrOpt SymbolHandle),+        '("im_info", AttrOpt SymbolHandle)]++_contrib_MultiProposal ::+                       forall args . Fullfilled "_contrib_MultiProposal(symbol)" args =>+                         String ->+                           ArgsHMap "_contrib_MultiProposal(symbol)" args -> IO SymbolHandle+_contrib_MultiProposal name args+  = let scalarArgs+          = catMaybes+              [("rpn_pre_nms_top_n",) . showValue <$>+                 (args !? #rpn_pre_nms_top_n :: Maybe Int),+               ("rpn_post_nms_top_n",) . showValue <$>+                 (args !? #rpn_post_nms_top_n :: Maybe Int),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("rpn_min_size",) . showValue <$>+                 (args !? #rpn_min_size :: Maybe Int),+               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("feature_stride",) . showValue <$>+                 (args !? #feature_stride :: Maybe Int),+               ("output_score",) . showValue <$>+                 (args !? #output_score :: Maybe Bool),+               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle),+               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe SymbolHandle),+               ("im_info",) <$> (args !? #im_info :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiProposal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_MultiProposal(symbol)" = '[]++_backward__contrib_MultiProposal ::+                                 forall args .+                                   Fullfilled "_backward__contrib_MultiProposal(symbol)" args =>+                                   String ->+                                     ArgsHMap "_backward__contrib_MultiProposal(symbol)" args ->+                                       IO SymbolHandle+_backward__contrib_MultiProposal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiProposal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_PSROIPooling(symbol)" =+     '[ '("spatial_scale", AttrReq Float), '("output_dim", AttrReq Int),+        '("pooled_size", AttrReq Int), '("group_size", AttrOpt Int),+        '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle)]++_contrib_PSROIPooling ::+                      forall args . Fullfilled "_contrib_PSROIPooling(symbol)" args =>+                        String ->+                          ArgsHMap "_contrib_PSROIPooling(symbol)" args -> IO SymbolHandle+_contrib_PSROIPooling name args+  = let scalarArgs+          = catMaybes+              [("spatial_scale",) . showValue <$>+                 (args !? #spatial_scale :: Maybe Float),+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),+               ("pooled_size",) . showValue <$>+                 (args !? #pooled_size :: Maybe Int),+               ("group_size",) . showValue <$> (args !? #group_size :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_PSROIPooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_PSROIPooling(symbol)" = '[]++_backward__contrib_PSROIPooling ::+                                forall args .+                                  Fullfilled "_backward__contrib_PSROIPooling(symbol)" args =>+                                  String ->+                                    ArgsHMap "_backward__contrib_PSROIPooling(symbol)" args ->+                                      IO SymbolHandle+_backward__contrib_PSROIPooling name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_PSROIPooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_contrib_DeformableConvolution(symbol)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("num_deformable_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("layout", AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NCW"]))),+        '("data", AttrOpt SymbolHandle), '("offset", AttrOpt SymbolHandle),+        '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle)]++_contrib_DeformableConvolution ::+                               forall args .+                                 Fullfilled "_contrib_DeformableConvolution(symbol)" args =>+                                 String ->+                                   ArgsHMap "_contrib_DeformableConvolution(symbol)" args ->+                                     IO SymbolHandle+_contrib_DeformableConvolution name args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("num_deformable_group",) . showValue <$>+                 (args !? #num_deformable_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("offset",) <$> (args !? #offset :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_DeformableConvolution"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_DeformableConvolution(symbol)" =+     '[]++_backward__contrib_DeformableConvolution ::+                                         forall args .+                                           Fullfilled+                                             "_backward__contrib_DeformableConvolution(symbol)"+                                             args =>+                                           String ->+                                             ArgsHMap+                                               "_backward__contrib_DeformableConvolution(symbol)"+                                               args+                                               -> IO SymbolHandle+_backward__contrib_DeformableConvolution name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_ifft(symbol)" =+     '[ '("compute_size", AttrOpt Int), '("data", AttrOpt SymbolHandle)]++_contrib_ifft ::+              forall args . Fullfilled "_contrib_ifft(symbol)" args =>+                String -> ArgsHMap "_contrib_ifft(symbol)" args -> IO SymbolHandle+_contrib_ifft name args+  = let scalarArgs+          = catMaybes+              [("compute_size",) . showValue <$>+                 (args !? #compute_size :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_ifft"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward__contrib_ifft(symbol)" = '[]++_backward__contrib_ifft ::+                        forall args . Fullfilled "_backward__contrib_ifft(symbol)" args =>+                          String ->+                            ArgsHMap "_backward__contrib_ifft(symbol)" args -> IO SymbolHandle+_backward__contrib_ifft name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_ifft"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_SyncBatchNorm(symbol)" = '[]++_backward__contrib_SyncBatchNorm ::+                                 forall args .+                                   Fullfilled "_backward__contrib_SyncBatchNorm(symbol)" args =>+                                   String ->+                                     ArgsHMap "_backward__contrib_SyncBatchNorm(symbol)" args ->+                                       IO SymbolHandle+_backward__contrib_SyncBatchNorm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_SyncBatchNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_InstanceNorm(symbol)" =+     '[ '("eps", AttrOpt Float), '("data", AttrOpt SymbolHandle),+        '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle)]++_InstanceNorm ::+              forall args . Fullfilled "_InstanceNorm(symbol)" args =>+                String -> ArgsHMap "_InstanceNorm(symbol)" args -> IO SymbolHandle+_InstanceNorm name args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),+               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "InstanceNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_InstanceNorm(symbol)" = '[]++_backward_InstanceNorm ::+                       forall args . Fullfilled "_backward_InstanceNorm(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_InstanceNorm(symbol)" args -> IO SymbolHandle+_backward_InstanceNorm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_InstanceNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SVMOutput(symbol)" =+     '[ '("margin", AttrOpt Float),+        '("regularization_coefficient", AttrOpt Float),+        '("use_linear", AttrOpt Bool), '("data", AttrOpt SymbolHandle),+        '("label", AttrOpt SymbolHandle)]++_SVMOutput ::+           forall args . Fullfilled "_SVMOutput(symbol)" args =>+             String -> ArgsHMap "_SVMOutput(symbol)" args -> IO SymbolHandle+_SVMOutput name args+  = let scalarArgs+          = catMaybes+              [("margin",) . showValue <$> (args !? #margin :: Maybe Float),+               ("regularization_coefficient",) . showValue <$>+                 (args !? #regularization_coefficient :: Maybe Float),+               ("use_linear",) . showValue <$>+                 (args !? #use_linear :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SVMOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SVMOutput(symbol)" = '[]++_backward_SVMOutput ::+                    forall args . Fullfilled "_backward_SVMOutput(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_SVMOutput(symbol)" args -> IO SymbolHandle+_backward_SVMOutput name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SVMOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_GridGenerator(symbol)" =+     '[ '("transform_type", AttrReq (EnumType '["affine", "warp"])),+        '("target_shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]++_GridGenerator ::+               forall args . Fullfilled "_GridGenerator(symbol)" args =>+                 String -> ArgsHMap "_GridGenerator(symbol)" args -> IO SymbolHandle+_GridGenerator name args+  = let scalarArgs+          = catMaybes+              [("transform_type",) . showValue <$>+                 (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "GridGenerator"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_GridGenerator(symbol)" = '[]++_backward_GridGenerator ::+                        forall args . Fullfilled "_backward_GridGenerator(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_GridGenerator(symbol)" args -> IO SymbolHandle+_backward_GridGenerator name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_GridGenerator"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Pad(symbol)" = '[]++_backward_Pad ::+              forall args . Fullfilled "_backward_Pad(symbol)" args =>+                String -> ArgsHMap "_backward_Pad(symbol)" args -> IO SymbolHandle+_backward_Pad name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pad"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Convolution_v1(symbol)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("cudnn_tune",+          AttrOpt+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+        '("cudnn_off", AttrOpt Bool),+        '("layout",+          AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"]))),+        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),+        '("bias", AttrOpt SymbolHandle)]++_Convolution_v1 ::+                forall args . Fullfilled "_Convolution_v1(symbol)" args =>+                  String ->+                    ArgsHMap "_Convolution_v1(symbol)" args -> IO SymbolHandle+_Convolution_v1 name args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Convolution_v1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Convolution_v1(symbol)" =+     '[]++_backward_Convolution_v1 ::+                         forall args . Fullfilled "_backward_Convolution_v1(symbol)" args =>+                           String ->+                             ArgsHMap "_backward_Convolution_v1(symbol)" args -> IO SymbolHandle+_backward_Convolution_v1 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Convolution_v1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SequenceReverse(symbol)" =+     '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int),+        '("data", AttrOpt SymbolHandle),+        '("sequence_length", AttrOpt SymbolHandle)]++_SequenceReverse ::+                 forall args . Fullfilled "_SequenceReverse(symbol)" args =>+                   String ->+                     ArgsHMap "_SequenceReverse(symbol)" args -> IO SymbolHandle+_SequenceReverse name args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceReverse"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SequenceReverse(symbol)" =+     '[]++_backward_SequenceReverse ::+                          forall args .+                            Fullfilled "_backward_SequenceReverse(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_SequenceReverse(symbol)" args ->+                                IO SymbolHandle+_backward_SequenceReverse name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceReverse"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SoftmaxOutput(symbol)" =+     '[ '("grad_scale", AttrOpt Float),+        '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool),+        '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool),+        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),+        '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float),+        '("data", AttrOpt SymbolHandle), '("label", AttrOpt SymbolHandle)]++_SoftmaxOutput ::+               forall args . Fullfilled "_SoftmaxOutput(symbol)" args =>+                 String -> ArgsHMap "_SoftmaxOutput(symbol)" args -> IO SymbolHandle+_SoftmaxOutput name args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float),+               ("ignore_label",) . showValue <$>+                 (args !? #ignore_label :: Maybe Float),+               ("multi_output",) . showValue <$>+                 (args !? #multi_output :: Maybe Bool),+               ("use_ignore",) . showValue <$>+                 (args !? #use_ignore :: Maybe Bool),+               ("preserve_shape",) . showValue <$>+                 (args !? #preserve_shape :: Maybe Bool),+               ("normalization",) . showValue <$>+                 (args !? #normalization ::+                    Maybe (EnumType '["batch", "null", "valid"])),+               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),+               ("smooth_alpha",) . showValue <$>+                 (args !? #smooth_alpha :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SoftmaxOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SoftmaxOutput(symbol)" = '[]++_backward_SoftmaxOutput ::+                        forall args . Fullfilled "_backward_SoftmaxOutput(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_SoftmaxOutput(symbol)" args -> IO SymbolHandle+_backward_SoftmaxOutput name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SoftmaxOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Softmax(symbol)" =+     '[ '("grad_scale", AttrOpt Float),+        '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool),+        '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool),+        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),+        '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float),+        '("data", AttrOpt SymbolHandle)]++_Softmax ::+         forall args . Fullfilled "_Softmax(symbol)" args =>+           String -> ArgsHMap "_Softmax(symbol)" args -> IO SymbolHandle+_Softmax name args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float),+               ("ignore_label",) . showValue <$>+                 (args !? #ignore_label :: Maybe Float),+               ("multi_output",) . showValue <$>+                 (args !? #multi_output :: Maybe Bool),+               ("use_ignore",) . showValue <$>+                 (args !? #use_ignore :: Maybe Bool),+               ("preserve_shape",) . showValue <$>+                 (args !? #preserve_shape :: Maybe Bool),+               ("normalization",) . showValue <$>+                 (args !? #normalization ::+                    Maybe (EnumType '["batch", "null", "valid"])),+               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),+               ("smooth_alpha",) . showValue <$>+                 (args !? #smooth_alpha :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Softmax"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Softmax(symbol)" = '[]++_backward_Softmax ::+                  forall args . Fullfilled "_backward_Softmax(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_Softmax(symbol)" args -> IO SymbolHandle+_backward_Softmax name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Softmax"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_BilinearSampler(symbol)" =+     '[ '("cudnn_off", AttrOpt (Maybe Bool)),+        '("data", AttrOpt SymbolHandle), '("grid", AttrOpt SymbolHandle)]++_BilinearSampler ::+                 forall args . Fullfilled "_BilinearSampler(symbol)" args =>+                   String ->+                     ArgsHMap "_BilinearSampler(symbol)" args -> IO SymbolHandle+_BilinearSampler name args+  = let scalarArgs+          = catMaybes+              [("cudnn_off",) . showValue <$>+                 (args !? #cudnn_off :: Maybe (Maybe Bool))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("grid",) <$> (args !? #grid :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BilinearSampler"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_BilinearSampler(symbol)" =+     '[]++_backward_BilinearSampler ::+                          forall args .+                            Fullfilled "_backward_BilinearSampler(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_BilinearSampler(symbol)" args ->+                                IO SymbolHandle+_backward_BilinearSampler name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BilinearSampler"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_LeakyReLU(symbol)" = '[]++_backward_LeakyReLU ::+                    forall args . Fullfilled "_backward_LeakyReLU(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_LeakyReLU(symbol)" args -> IO SymbolHandle+_backward_LeakyReLU name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LeakyReLU"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Crop(symbol)" =+     '[ '("num_args", AttrReq Int), '("offset", AttrOpt [Int]),+        '("h_w", AttrOpt [Int]), '("center_crop", AttrOpt Bool),+        '("data", AttrOpt [SymbolHandle])]++_Crop ::+      forall args . Fullfilled "_Crop(symbol)" args =>+        String -> ArgsHMap "_Crop(symbol)" args -> IO SymbolHandle+_Crop name args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]),+               ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]),+               ("center_crop",) . showValue <$>+                 (args !? #center_crop :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "Crop"+         sym <- if hasKey args #num_args then+                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals+                  else+                  mxSymbolCreateAtomicSymbol (fromOpHandle op)+                    ("num_args" : scalarkeys)+                    (showValue (length array) : scalarvals)+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_backward_Crop(symbol)" = '[]++_backward_Crop ::+               forall args . Fullfilled "_backward_Crop(symbol)" args =>+                 String -> ArgsHMap "_backward_Crop(symbol)" args -> IO SymbolHandle+_backward_Crop name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Crop"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_ROIPooling(symbol)" =+     '[ '("pooled_size", AttrReq [Int]),+        '("spatial_scale", AttrReq Float), '("data", AttrOpt SymbolHandle),+        '("rois", AttrOpt SymbolHandle)]++_ROIPooling ::+            forall args . Fullfilled "_ROIPooling(symbol)" args =>+              String -> ArgsHMap "_ROIPooling(symbol)" args -> IO SymbolHandle+_ROIPooling name args+  = let scalarArgs+          = catMaybes+              [("pooled_size",) . showValue <$>+                 (args !? #pooled_size :: Maybe [Int]),+               ("spatial_scale",) . showValue <$>+                 (args !? #spatial_scale :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ROIPooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_ROIPooling(symbol)" = '[]++_backward_ROIPooling ::+                     forall args . Fullfilled "_backward_ROIPooling(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_ROIPooling(symbol)" args -> IO SymbolHandle+_backward_ROIPooling name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_ROIPooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SequenceLast(symbol)" =+     '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int),+        '("data", AttrOpt SymbolHandle),+        '("sequence_length", AttrOpt SymbolHandle)]++_SequenceLast ::+              forall args . Fullfilled "_SequenceLast(symbol)" args =>+                String -> ArgsHMap "_SequenceLast(symbol)" args -> IO SymbolHandle+_SequenceLast name args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceLast"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SequenceLast(symbol)" = '[]++_backward_SequenceLast ::+                       forall args . Fullfilled "_backward_SequenceLast(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_SequenceLast(symbol)" args -> IO SymbolHandle+_backward_SequenceLast name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceLast"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_CrossDeviceCopy(symbol)" = '[]++_CrossDeviceCopy ::+                 forall args . Fullfilled "_CrossDeviceCopy(symbol)" args =>+                   String ->+                     ArgsHMap "_CrossDeviceCopy(symbol)" args -> IO SymbolHandle+_CrossDeviceCopy name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_CrossDeviceCopy"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward__CrossDeviceCopy(symbol)" =+     '[]++_backward__CrossDeviceCopy ::+                           forall args .+                             Fullfilled "_backward__CrossDeviceCopy(symbol)" args =>+                             String ->+                               ArgsHMap "_backward__CrossDeviceCopy(symbol)" args ->+                                 IO SymbolHandle+_backward__CrossDeviceCopy name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__CrossDeviceCopy"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SpatialTransformer(symbol)" =+     '[ '("target_shape", AttrOpt [Int]),+        '("transform_type", AttrReq (EnumType '["affine"])),+        '("sampler_type", AttrReq (EnumType '["bilinear"])),+        '("cudnn_off", AttrOpt (Maybe Bool)),+        '("data", AttrOpt SymbolHandle), '("loc", AttrOpt SymbolHandle)]++_SpatialTransformer ::+                    forall args . Fullfilled "_SpatialTransformer(symbol)" args =>+                      String ->+                        ArgsHMap "_SpatialTransformer(symbol)" args -> IO SymbolHandle+_SpatialTransformer name args+  = let scalarArgs+          = catMaybes+              [("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("transform_type",) . showValue <$>+                 (args !? #transform_type :: Maybe (EnumType '["affine"])),+               ("sampler_type",) . showValue <$>+                 (args !? #sampler_type :: Maybe (EnumType '["bilinear"])),+               ("cudnn_off",) . showValue <$>+                 (args !? #cudnn_off :: Maybe (Maybe Bool))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("loc",) <$> (args !? #loc :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SpatialTransformer"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SpatialTransformer(symbol)"+     = '[]++_backward_SpatialTransformer ::+                             forall args .+                               Fullfilled "_backward_SpatialTransformer(symbol)" args =>+                               String ->+                                 ArgsHMap "_backward_SpatialTransformer(symbol)" args ->+                                   IO SymbolHandle+_backward_SpatialTransformer name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SpatialTransformer"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SwapAxis(symbol)" = '[]++_backward_SwapAxis ::+                   forall args . Fullfilled "_backward_SwapAxis(symbol)" args =>+                     String ->+                       ArgsHMap "_backward_SwapAxis(symbol)" args -> IO SymbolHandle+_backward_SwapAxis name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SwapAxis"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_L2Normalization(symbol)" =+     '[ '("eps", AttrOpt Float),+        '("mode", AttrOpt (EnumType '["channel", "instance", "spatial"])),+        '("data", AttrOpt SymbolHandle)]++_L2Normalization ::+                 forall args . Fullfilled "_L2Normalization(symbol)" args =>+                   String ->+                     ArgsHMap "_L2Normalization(symbol)" args -> IO SymbolHandle+_L2Normalization name args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["channel", "instance", "spatial"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "L2Normalization"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_L2Normalization(symbol)" =+     '[]++_backward_L2Normalization ::+                          forall args .+                            Fullfilled "_backward_L2Normalization(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_L2Normalization(symbol)" args ->+                                IO SymbolHandle+_backward_L2Normalization name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_L2Normalization"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Correlation(symbol)" =+     '[ '("kernel_size", AttrOpt Int),+        '("max_displacement", AttrOpt Int), '("stride1", AttrOpt Int),+        '("stride2", AttrOpt Int), '("pad_size", AttrOpt Int),+        '("is_multiply", AttrOpt Bool), '("data1", AttrOpt SymbolHandle),+        '("data2", AttrOpt SymbolHandle)]++_Correlation ::+             forall args . Fullfilled "_Correlation(symbol)" args =>+               String -> ArgsHMap "_Correlation(symbol)" args -> IO SymbolHandle+_Correlation name args+  = let scalarArgs+          = catMaybes+              [("kernel_size",) . showValue <$>+                 (args !? #kernel_size :: Maybe Int),+               ("max_displacement",) . showValue <$>+                 (args !? #max_displacement :: Maybe Int),+               ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int),+               ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int),+               ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int),+               ("is_multiply",) . showValue <$>+                 (args !? #is_multiply :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data1",) <$> (args !? #data1 :: Maybe SymbolHandle),+               ("data2",) <$> (args !? #data2 :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Correlation"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Correlation(symbol)" = '[]++_backward_Correlation ::+                      forall args . Fullfilled "_backward_Correlation(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_Correlation(symbol)" args -> IO SymbolHandle+_backward_Correlation name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Correlation"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward_IdentityAttachKLSparseReg(symbol)" = '[]++_backward_IdentityAttachKLSparseReg ::+                                    forall args .+                                      Fullfilled "_backward_IdentityAttachKLSparseReg(symbol)"+                                        args =>+                                      String ->+                                        ArgsHMap "_backward_IdentityAttachKLSparseReg(symbol)" args+                                          -> IO SymbolHandle+_backward_IdentityAttachKLSparseReg name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_MakeLoss(symbol)" =+     '[ '("grad_scale", AttrOpt Float),+        '("valid_thresh", AttrOpt Float),+        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),+        '("data", AttrOpt SymbolHandle)]++_MakeLoss ::+          forall args . Fullfilled "_MakeLoss(symbol)" args =>+            String -> ArgsHMap "_MakeLoss(symbol)" args -> IO SymbolHandle+_MakeLoss name args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float),+               ("valid_thresh",) . showValue <$>+                 (args !? #valid_thresh :: Maybe Float),+               ("normalization",) . showValue <$>+                 (args !? #normalization ::+                    Maybe (EnumType '["batch", "null", "valid"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "MakeLoss"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_MakeLoss(symbol)" = '[]++_backward_MakeLoss ::+                   forall args . Fullfilled "_backward_MakeLoss(symbol)" args =>+                     String ->+                       ArgsHMap "_backward_MakeLoss(symbol)" args -> IO SymbolHandle+_backward_MakeLoss name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_MakeLoss"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SliceChannel(symbol)" = '[]++_backward_SliceChannel ::+                       forall args . Fullfilled "_backward_SliceChannel(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_SliceChannel(symbol)" args -> IO SymbolHandle+_backward_SliceChannel name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SliceChannel"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_RNN(symbol)" =+     '[ '("state_size", AttrReq Int), '("num_layers", AttrReq Int),+        '("bidirectional", AttrOpt Bool),+        '("mode",+          AttrReq (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),+        '("p", AttrOpt Float), '("state_outputs", AttrOpt Bool),+        '("projection_size", AttrOpt (Maybe Int)),+        '("lstm_state_clip_min", AttrOpt (Maybe Double)),+        '("lstm_state_clip_max", AttrOpt (Maybe Double)),+        '("lstm_state_clip_nan", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle),+        '("parameters", AttrOpt SymbolHandle),+        '("state", AttrOpt SymbolHandle),+        '("state_cell", AttrOpt SymbolHandle)]++_RNN ::+     forall args . Fullfilled "_RNN(symbol)" args =>+       String -> ArgsHMap "_RNN(symbol)" args -> IO SymbolHandle+_RNN name args+  = let scalarArgs+          = catMaybes+              [("state_size",) . showValue <$>+                 (args !? #state_size :: Maybe Int),+               ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int),+               ("bidirectional",) . showValue <$>+                 (args !? #bidirectional :: Maybe Bool),+               ("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),+               ("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("state_outputs",) . showValue <$>+                 (args !? #state_outputs :: Maybe Bool),+               ("projection_size",) . showValue <$>+                 (args !? #projection_size :: Maybe (Maybe Int)),+               ("lstm_state_clip_min",) . showValue <$>+                 (args !? #lstm_state_clip_min :: Maybe (Maybe Double)),+               ("lstm_state_clip_max",) . showValue <$>+                 (args !? #lstm_state_clip_max :: Maybe (Maybe Double)),+               ("lstm_state_clip_nan",) . showValue <$>+                 (args !? #lstm_state_clip_nan :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("parameters",) <$> (args !? #parameters :: Maybe SymbolHandle),+               ("state",) <$> (args !? #state :: Maybe SymbolHandle),+               ("state_cell",) <$> (args !? #state_cell :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "RNN"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_RNN(symbol)" = '[]++_backward_RNN ::+              forall args . Fullfilled "_backward_RNN(symbol)" args =>+                String -> ArgsHMap "_backward_RNN(symbol)" args -> IO SymbolHandle+_backward_RNN name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_RNN"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Pooling_v1(symbol)" =+     '[ '("kernel", AttrOpt [Int]),+        '("pool_type", AttrOpt (EnumType '["avg", "max", "sum"])),+        '("global_pool", AttrOpt Bool),+        '("pooling_convention", AttrOpt (EnumType '["full", "valid"])),+        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("data", AttrOpt SymbolHandle)]++_Pooling_v1 ::+            forall args . Fullfilled "_Pooling_v1(symbol)" args =>+              String -> ArgsHMap "_Pooling_v1(symbol)" args -> IO SymbolHandle+_Pooling_v1 name args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("pool_type",) . showValue <$>+                 (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])),+               ("global_pool",) . showValue <$>+                 (args !? #global_pool :: Maybe Bool),+               ("pooling_convention",) . showValue <$>+                 (args !? #pooling_convention ::+                    Maybe (EnumType '["full", "valid"])),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pooling_v1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Pooling_v1(symbol)" = '[]++_backward_Pooling_v1 ::+                     forall args . Fullfilled "_backward_Pooling_v1(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_Pooling_v1(symbol)" args -> IO SymbolHandle+_backward_Pooling_v1 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pooling_v1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_BatchNorm_v1(symbol)" = '[]++_backward_BatchNorm_v1 ::+                       forall args . Fullfilled "_backward_BatchNorm_v1(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_BatchNorm_v1(symbol)" args -> IO SymbolHandle+_backward_BatchNorm_v1 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BatchNorm_v1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SequenceMask(symbol)" =+     '[ '("use_sequence_length", AttrOpt Bool),+        '("value", AttrOpt Float), '("axis", AttrOpt Int),+        '("data", AttrOpt SymbolHandle),+        '("sequence_length", AttrOpt SymbolHandle)]++_SequenceMask ::+              forall args . Fullfilled "_SequenceMask(symbol)" args =>+                String -> ArgsHMap "_SequenceMask(symbol)" args -> IO SymbolHandle+_SequenceMask name args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool),+               ("value",) . showValue <$> (args !? #value :: Maybe Float),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceMask"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SequenceMask(symbol)" = '[]++_backward_SequenceMask ::+                       forall args . Fullfilled "_backward_SequenceMask(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_SequenceMask(symbol)" args -> IO SymbolHandle+_backward_SequenceMask name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceMask"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_set_value(symbol)" =+     '[ '("src", AttrOpt Float)]++_set_value ::+           forall args . Fullfilled "_set_value(symbol)" args =>+             String -> ArgsHMap "_set_value(symbol)" args -> IO SymbolHandle+_set_value name args+  = let scalarArgs+          = catMaybes+              [("src",) . showValue <$> (args !? #src :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_set_value"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_imdecode(symbol)" =+     '[ '("index", AttrOpt Int), '("x0", AttrOpt Int),+        '("y0", AttrOpt Int), '("x1", AttrOpt Int), '("y1", AttrOpt Int),+        '("c", AttrOpt Int), '("size", AttrOpt Int),+        '("mean", AttrOpt SymbolHandle)]++_imdecode ::+          forall args . Fullfilled "_imdecode(symbol)" args =>+            String -> ArgsHMap "_imdecode(symbol)" args -> IO SymbolHandle+_imdecode name args+  = let scalarArgs+          = catMaybes+              [("index",) . showValue <$> (args !? #index :: Maybe Int),+               ("x0",) . showValue <$> (args !? #x0 :: Maybe Int),+               ("y0",) . showValue <$> (args !? #y0 :: Maybe Int),+               ("x1",) . showValue <$> (args !? #x1 :: Maybe Int),+               ("y1",) . showValue <$> (args !? #y1 :: Maybe Int),+               ("c",) . showValue <$> (args !? #c :: Maybe Int),+               ("size",) . showValue <$> (args !? #size :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("mean",) <$> (args !? #mean :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_imdecode"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym
+ ops/1.5/MXNet/Base/Operators/NDArray.hs view
@@ -0,0 +1,23053 @@+module MXNet.Base.Operators.NDArray where+import MXNet.Base.Raw+import MXNet.Base.Spec.Operator+import MXNet.Base.Spec.HMap+import Data.Maybe (catMaybes, fromMaybe)++type instance ParameterList "_CuDNNBatchNorm(ndarray)" =+     '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float),+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),+        '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int),+        '("cudnn_off", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),+        '("gamma", AttrOpt NDArrayHandle),+        '("beta", AttrOpt NDArrayHandle),+        '("moving_mean", AttrOpt NDArrayHandle),+        '("moving_var", AttrOpt NDArrayHandle)]++_CuDNNBatchNorm ::+                forall args . Fullfilled "_CuDNNBatchNorm(ndarray)" args =>+                  ArgsHMap "_CuDNNBatchNorm(ndarray)" args -> IO [NDArrayHandle]+_CuDNNBatchNorm args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),+               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),+               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "CuDNNBatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_CuDNNBatchNorm_upd ::+                    forall args . Fullfilled "_CuDNNBatchNorm(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_CuDNNBatchNorm(ndarray)" args -> IO ()+_CuDNNBatchNorm_upd outputs args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),+               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),+               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "CuDNNBatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_CuDNNBatchNorm(ndarray)" =+     '[]++_backward_CuDNNBatchNorm ::+                         forall args .+                           Fullfilled "_backward_CuDNNBatchNorm(ndarray)" args =>+                           ArgsHMap "_backward_CuDNNBatchNorm(ndarray)" args ->+                             IO [NDArrayHandle]+_backward_CuDNNBatchNorm args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_CuDNNBatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_CuDNNBatchNorm_upd ::+                             forall args .+                               Fullfilled "_backward_CuDNNBatchNorm(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_backward_CuDNNBatchNorm(ndarray)" args -> IO ()+_backward_CuDNNBatchNorm_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_CuDNNBatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_sample_multinomial(ndarray)" =+     '[ '("shape", AttrOpt [Int]), '("get_prob", AttrOpt Bool),+        '("dtype",+          AttrOpt+            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),+        '("data", AttrOpt NDArrayHandle)]++_sample_multinomial ::+                    forall args . Fullfilled "_sample_multinomial(ndarray)" args =>+                      ArgsHMap "_sample_multinomial(ndarray)" args -> IO [NDArrayHandle]+_sample_multinomial args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_multinomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sample_multinomial_upd ::+                        forall args . Fullfilled "_sample_multinomial(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_sample_multinomial(ndarray)" args -> IO ()+_sample_multinomial_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_multinomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_sample_multinomial(ndarray)"+     = '[]++_backward_sample_multinomial ::+                             forall args .+                               Fullfilled "_backward_sample_multinomial(ndarray)" args =>+                               ArgsHMap "_backward_sample_multinomial(ndarray)" args ->+                                 IO [NDArrayHandle]+_backward_sample_multinomial args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sample_multinomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_sample_multinomial_upd ::+                                 forall args .+                                   Fullfilled "_backward_sample_multinomial(ndarray)" args =>+                                   [NDArrayHandle] ->+                                     ArgsHMap "_backward_sample_multinomial(ndarray)" args -> IO ()+_backward_sample_multinomial_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sample_multinomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_sample_uniform(ndarray)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("low", AttrOpt NDArrayHandle), '("high", AttrOpt NDArrayHandle)]++_sample_uniform ::+                forall args . Fullfilled "_sample_uniform(ndarray)" args =>+                  ArgsHMap "_sample_uniform(ndarray)" args -> IO [NDArrayHandle]+_sample_uniform args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("low",) <$> (args !? #low :: Maybe NDArrayHandle),+               ("high",) <$> (args !? #high :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_uniform"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sample_uniform_upd ::+                    forall args . Fullfilled "_sample_uniform(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_sample_uniform(ndarray)" args -> IO ()+_sample_uniform_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("low",) <$> (args !? #low :: Maybe NDArrayHandle),+               ("high",) <$> (args !? #high :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_uniform"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_sample_normal(ndarray)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("mu", AttrOpt NDArrayHandle), '("sigma", AttrOpt NDArrayHandle)]++_sample_normal ::+               forall args . Fullfilled "_sample_normal(ndarray)" args =>+                 ArgsHMap "_sample_normal(ndarray)" args -> IO [NDArrayHandle]+_sample_normal args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle),+               ("sigma",) <$> (args !? #sigma :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_normal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sample_normal_upd ::+                   forall args . Fullfilled "_sample_normal(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_sample_normal(ndarray)" args -> IO ()+_sample_normal_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle),+               ("sigma",) <$> (args !? #sigma :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_normal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_sample_gamma(ndarray)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("alpha", AttrOpt NDArrayHandle),+        '("beta", AttrOpt NDArrayHandle)]++_sample_gamma ::+              forall args . Fullfilled "_sample_gamma(ndarray)" args =>+                ArgsHMap "_sample_gamma(ndarray)" args -> IO [NDArrayHandle]+_sample_gamma args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_gamma"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sample_gamma_upd ::+                  forall args . Fullfilled "_sample_gamma(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_sample_gamma(ndarray)" args -> IO ()+_sample_gamma_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_gamma"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_sample_exponential(ndarray)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("lam", AttrOpt NDArrayHandle)]++_sample_exponential ::+                    forall args . Fullfilled "_sample_exponential(ndarray)" args =>+                      ArgsHMap "_sample_exponential(ndarray)" args -> IO [NDArrayHandle]+_sample_exponential args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_exponential"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sample_exponential_upd ::+                        forall args . Fullfilled "_sample_exponential(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_sample_exponential(ndarray)" args -> IO ()+_sample_exponential_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_exponential"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_sample_poisson(ndarray)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("lam", AttrOpt NDArrayHandle)]++_sample_poisson ::+                forall args . Fullfilled "_sample_poisson(ndarray)" args =>+                  ArgsHMap "_sample_poisson(ndarray)" args -> IO [NDArrayHandle]+_sample_poisson args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_poisson"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sample_poisson_upd ::+                    forall args . Fullfilled "_sample_poisson(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_sample_poisson(ndarray)" args -> IO ()+_sample_poisson_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_poisson"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_sample_negative_binomial(ndarray)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("k", AttrOpt NDArrayHandle), '("p", AttrOpt NDArrayHandle)]++_sample_negative_binomial ::+                          forall args .+                            Fullfilled "_sample_negative_binomial(ndarray)" args =>+                            ArgsHMap "_sample_negative_binomial(ndarray)" args ->+                              IO [NDArrayHandle]+_sample_negative_binomial args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("k",) <$> (args !? #k :: Maybe NDArrayHandle),+               ("p",) <$> (args !? #p :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_negative_binomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sample_negative_binomial_upd ::+                              forall args .+                                Fullfilled "_sample_negative_binomial(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_sample_negative_binomial(ndarray)" args -> IO ()+_sample_negative_binomial_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("k",) <$> (args !? #k :: Maybe NDArrayHandle),+               ("p",) <$> (args !? #p :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_negative_binomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_sample_generalized_negative_binomial(ndarray)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("mu", AttrOpt NDArrayHandle), '("alpha", AttrOpt NDArrayHandle)]++_sample_generalized_negative_binomial ::+                                      forall args .+                                        Fullfilled "_sample_generalized_negative_binomial(ndarray)"+                                          args =>+                                        ArgsHMap "_sample_generalized_negative_binomial(ndarray)"+                                          args+                                          -> IO [NDArrayHandle]+_sample_generalized_negative_binomial args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle),+               ("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_generalized_negative_binomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sample_generalized_negative_binomial_upd ::+                                          forall args .+                                            Fullfilled+                                              "_sample_generalized_negative_binomial(ndarray)"+                                              args =>+                                            [NDArrayHandle] ->+                                              ArgsHMap+                                                "_sample_generalized_negative_binomial(ndarray)"+                                                args+                                                -> IO ()+_sample_generalized_negative_binomial_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs+          = catMaybes+              [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle),+               ("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_generalized_negative_binomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_sample_unique_zipfian(ndarray)" =+     '[ '("range_max", AttrReq Int), '("shape", AttrOpt [Int])]++_sample_unique_zipfian ::+                       forall args . Fullfilled "_sample_unique_zipfian(ndarray)" args =>+                         ArgsHMap "_sample_unique_zipfian(ndarray)" args ->+                           IO [NDArrayHandle]+_sample_unique_zipfian args+  = let scalarArgs+          = catMaybes+              [("range_max",) . showValue <$> (args !? #range_max :: Maybe Int),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_unique_zipfian"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sample_unique_zipfian_upd ::+                           forall args . Fullfilled "_sample_unique_zipfian(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_sample_unique_zipfian(ndarray)" args -> IO ()+_sample_unique_zipfian_upd outputs args+  = let scalarArgs+          = catMaybes+              [("range_max",) . showValue <$> (args !? #range_max :: Maybe Int),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_unique_zipfian"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_uniform(ndarray)" =+     '[ '("low", AttrOpt Float), '("high", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_uniform ::+                forall args . Fullfilled "_random_uniform(ndarray)" args =>+                  ArgsHMap "_random_uniform(ndarray)" args -> IO [NDArrayHandle]+_random_uniform args+  = let scalarArgs+          = catMaybes+              [("low",) . showValue <$> (args !? #low :: Maybe Float),+               ("high",) . showValue <$> (args !? #high :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_uniform"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_uniform_upd ::+                    forall args . Fullfilled "_random_uniform(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_random_uniform(ndarray)" args -> IO ()+_random_uniform_upd outputs args+  = let scalarArgs+          = catMaybes+              [("low",) . showValue <$> (args !? #low :: Maybe Float),+               ("high",) . showValue <$> (args !? #high :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_uniform"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_normal(ndarray)" =+     '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_normal ::+               forall args . Fullfilled "_random_normal(ndarray)" args =>+                 ArgsHMap "_random_normal(ndarray)" args -> IO [NDArrayHandle]+_random_normal args+  = let scalarArgs+          = catMaybes+              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),+               ("scale",) . showValue <$> (args !? #scale :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_normal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_normal_upd ::+                   forall args . Fullfilled "_random_normal(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_random_normal(ndarray)" args -> IO ()+_random_normal_upd outputs args+  = let scalarArgs+          = catMaybes+              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),+               ("scale",) . showValue <$> (args !? #scale :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_normal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_gamma(ndarray)" =+     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_gamma ::+              forall args . Fullfilled "_random_gamma(ndarray)" args =>+                ArgsHMap "_random_gamma(ndarray)" args -> IO [NDArrayHandle]+_random_gamma args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_gamma"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_gamma_upd ::+                  forall args . Fullfilled "_random_gamma(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_random_gamma(ndarray)" args -> IO ()+_random_gamma_upd outputs args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_gamma"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_exponential(ndarray)" =+     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),+        '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_exponential ::+                    forall args . Fullfilled "_random_exponential(ndarray)" args =>+                      ArgsHMap "_random_exponential(ndarray)" args -> IO [NDArrayHandle]+_random_exponential args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_exponential"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_exponential_upd ::+                        forall args . Fullfilled "_random_exponential(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_random_exponential(ndarray)" args -> IO ()+_random_exponential_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_exponential"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_poisson(ndarray)" =+     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),+        '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_poisson ::+                forall args . Fullfilled "_random_poisson(ndarray)" args =>+                  ArgsHMap "_random_poisson(ndarray)" args -> IO [NDArrayHandle]+_random_poisson args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_poisson"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_poisson_upd ::+                    forall args . Fullfilled "_random_poisson(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_random_poisson(ndarray)" args -> IO ()+_random_poisson_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_poisson"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_negative_binomial(ndarray)" =+     '[ '("k", AttrOpt Int), '("p", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_negative_binomial ::+                          forall args .+                            Fullfilled "_random_negative_binomial(ndarray)" args =>+                            ArgsHMap "_random_negative_binomial(ndarray)" args ->+                              IO [NDArrayHandle]+_random_negative_binomial args+  = let scalarArgs+          = catMaybes+              [("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_negative_binomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_negative_binomial_upd ::+                              forall args .+                                Fullfilled "_random_negative_binomial(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_random_negative_binomial(ndarray)" args -> IO ()+_random_negative_binomial_upd outputs args+  = let scalarArgs+          = catMaybes+              [("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_negative_binomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_random_generalized_negative_binomial(ndarray)" =+     '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_generalized_negative_binomial ::+                                      forall args .+                                        Fullfilled "_random_generalized_negative_binomial(ndarray)"+                                          args =>+                                        ArgsHMap "_random_generalized_negative_binomial(ndarray)"+                                          args+                                          -> IO [NDArrayHandle]+_random_generalized_negative_binomial args+  = let scalarArgs+          = catMaybes+              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_generalized_negative_binomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_generalized_negative_binomial_upd ::+                                          forall args .+                                            Fullfilled+                                              "_random_generalized_negative_binomial(ndarray)"+                                              args =>+                                            [NDArrayHandle] ->+                                              ArgsHMap+                                                "_random_generalized_negative_binomial(ndarray)"+                                                args+                                                -> IO ()+_random_generalized_negative_binomial_upd outputs args+  = let scalarArgs+          = catMaybes+              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_generalized_negative_binomial"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_randint(ndarray)" =+     '[ '("low", AttrReq Int), '("high", AttrReq Int),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype", AttrOpt (EnumType '["None", "int32", "int64"]))]++_random_randint ::+                forall args . Fullfilled "_random_randint(ndarray)" args =>+                  ArgsHMap "_random_randint(ndarray)" args -> IO [NDArrayHandle]+_random_randint args+  = let scalarArgs+          = catMaybes+              [("low",) . showValue <$> (args !? #low :: Maybe Int),+               ("high",) . showValue <$> (args !? #high :: Maybe Int),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype :: Maybe (EnumType '["None", "int32", "int64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_randint"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_randint_upd ::+                    forall args . Fullfilled "_random_randint(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_random_randint(ndarray)" args -> IO ()+_random_randint_upd outputs args+  = let scalarArgs+          = catMaybes+              [("low",) . showValue <$> (args !? #low :: Maybe Int),+               ("high",) . showValue <$> (args !? #high :: Maybe Int),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype :: Maybe (EnumType '["None", "int32", "int64"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_randint"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_uniform_like(ndarray)" =+     '[ '("low", AttrOpt Float), '("high", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle)]++_random_uniform_like ::+                     forall args . Fullfilled "_random_uniform_like(ndarray)" args =>+                       ArgsHMap "_random_uniform_like(ndarray)" args -> IO [NDArrayHandle]+_random_uniform_like args+  = let scalarArgs+          = catMaybes+              [("low",) . showValue <$> (args !? #low :: Maybe Float),+               ("high",) . showValue <$> (args !? #high :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_uniform_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_uniform_like_upd ::+                         forall args . Fullfilled "_random_uniform_like(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_random_uniform_like(ndarray)" args -> IO ()+_random_uniform_like_upd outputs args+  = let scalarArgs+          = catMaybes+              [("low",) . showValue <$> (args !? #low :: Maybe Float),+               ("high",) . showValue <$> (args !? #high :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_uniform_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_normal_like(ndarray)" =+     '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle)]++_random_normal_like ::+                    forall args . Fullfilled "_random_normal_like(ndarray)" args =>+                      ArgsHMap "_random_normal_like(ndarray)" args -> IO [NDArrayHandle]+_random_normal_like args+  = let scalarArgs+          = catMaybes+              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),+               ("scale",) . showValue <$> (args !? #scale :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_normal_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_normal_like_upd ::+                        forall args . Fullfilled "_random_normal_like(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_random_normal_like(ndarray)" args -> IO ()+_random_normal_like_upd outputs args+  = let scalarArgs+          = catMaybes+              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),+               ("scale",) . showValue <$> (args !? #scale :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_normal_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_gamma_like(ndarray)" =+     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle)]++_random_gamma_like ::+                   forall args . Fullfilled "_random_gamma_like(ndarray)" args =>+                     ArgsHMap "_random_gamma_like(ndarray)" args -> IO [NDArrayHandle]+_random_gamma_like args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_gamma_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_gamma_like_upd ::+                       forall args . Fullfilled "_random_gamma_like(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_random_gamma_like(ndarray)" args -> IO ()+_random_gamma_like_upd outputs args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_gamma_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_exponential_like(ndarray)" =+     '[ '("lam", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_random_exponential_like ::+                         forall args .+                           Fullfilled "_random_exponential_like(ndarray)" args =>+                           ArgsHMap "_random_exponential_like(ndarray)" args ->+                             IO [NDArrayHandle]+_random_exponential_like args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_exponential_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_exponential_like_upd ::+                             forall args .+                               Fullfilled "_random_exponential_like(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_random_exponential_like(ndarray)" args -> IO ()+_random_exponential_like_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_exponential_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_random_poisson_like(ndarray)" =+     '[ '("lam", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_random_poisson_like ::+                     forall args . Fullfilled "_random_poisson_like(ndarray)" args =>+                       ArgsHMap "_random_poisson_like(ndarray)" args -> IO [NDArrayHandle]+_random_poisson_like args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_poisson_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_poisson_like_upd ::+                         forall args . Fullfilled "_random_poisson_like(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_random_poisson_like(ndarray)" args -> IO ()+_random_poisson_like_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_poisson_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_random_negative_binomial_like(ndarray)" =+     '[ '("k", AttrOpt Int), '("p", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle)]++_random_negative_binomial_like ::+                               forall args .+                                 Fullfilled "_random_negative_binomial_like(ndarray)" args =>+                                 ArgsHMap "_random_negative_binomial_like(ndarray)" args ->+                                   IO [NDArrayHandle]+_random_negative_binomial_like args+  = let scalarArgs+          = catMaybes+              [("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("p",) . showValue <$> (args !? #p :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_negative_binomial_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_negative_binomial_like_upd ::+                                   forall args .+                                     Fullfilled "_random_negative_binomial_like(ndarray)" args =>+                                     [NDArrayHandle] ->+                                       ArgsHMap "_random_negative_binomial_like(ndarray)" args ->+                                         IO ()+_random_negative_binomial_like_upd outputs args+  = let scalarArgs+          = catMaybes+              [("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("p",) . showValue <$> (args !? #p :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_negative_binomial_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_random_generalized_negative_binomial_like(ndarray)"+     =+     '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle)]++_random_generalized_negative_binomial_like ::+                                           forall args .+                                             Fullfilled+                                               "_random_generalized_negative_binomial_like(ndarray)"+                                               args =>+                                             ArgsHMap+                                               "_random_generalized_negative_binomial_like(ndarray)"+                                               args+                                               -> IO [NDArrayHandle]+_random_generalized_negative_binomial_like args+  = let scalarArgs+          = catMaybes+              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_generalized_negative_binomial_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_random_generalized_negative_binomial_like_upd ::+                                               forall args .+                                                 Fullfilled+                                                   "_random_generalized_negative_binomial_like(ndarray)"+                                                   args =>+                                                 [NDArrayHandle] ->+                                                   ArgsHMap+                                                     "_random_generalized_negative_binomial_like(ndarray)"+                                                     args+                                                     -> IO ()+_random_generalized_negative_binomial_like_upd outputs args+  = let scalarArgs+          = catMaybes+              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_generalized_negative_binomial_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_shuffle(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_shuffle ::+         forall args . Fullfilled "_shuffle(ndarray)" args =>+           ArgsHMap "_shuffle(ndarray)" args -> IO [NDArrayHandle]+_shuffle args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_shuffle"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_shuffle_upd ::+             forall args . Fullfilled "_shuffle(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "_shuffle(ndarray)" args -> IO ()+_shuffle_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_shuffle"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Custom(ndarray)" = '[]++_backward_Custom ::+                 forall args . Fullfilled "_backward_Custom(ndarray)" args =>+                   ArgsHMap "_backward_Custom(ndarray)" args -> IO [NDArrayHandle]+_backward_Custom args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Custom"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Custom_upd ::+                     forall args . Fullfilled "_backward_Custom(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_backward_Custom(ndarray)" args -> IO ()+_backward_Custom_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Custom"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_power(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_power ::+                forall args . Fullfilled "broadcast_power(ndarray)" args =>+                  ArgsHMap "broadcast_power(ndarray)" args -> IO [NDArrayHandle]+broadcast_power args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_power"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_power_upd ::+                    forall args . Fullfilled "broadcast_power(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "broadcast_power(ndarray)" args -> IO ()+broadcast_power_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_power"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_broadcast_power(ndarray)" =+     '[]++_backward_broadcast_power ::+                          forall args .+                            Fullfilled "_backward_broadcast_power(ndarray)" args =>+                            ArgsHMap "_backward_broadcast_power(ndarray)" args ->+                              IO [NDArrayHandle]+_backward_broadcast_power args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_power"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_broadcast_power_upd ::+                              forall args .+                                Fullfilled "_backward_broadcast_power(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_backward_broadcast_power(ndarray)" args -> IO ()+_backward_broadcast_power_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_power"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_maximum(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_maximum ::+                  forall args . Fullfilled "broadcast_maximum(ndarray)" args =>+                    ArgsHMap "broadcast_maximum(ndarray)" args -> IO [NDArrayHandle]+broadcast_maximum args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_maximum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_maximum_upd ::+                      forall args . Fullfilled "broadcast_maximum(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "broadcast_maximum(ndarray)" args -> IO ()+broadcast_maximum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_maximum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_broadcast_maximum(ndarray)"+     = '[]++_backward_broadcast_maximum ::+                            forall args .+                              Fullfilled "_backward_broadcast_maximum(ndarray)" args =>+                              ArgsHMap "_backward_broadcast_maximum(ndarray)" args ->+                                IO [NDArrayHandle]+_backward_broadcast_maximum args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_maximum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_broadcast_maximum_upd ::+                                forall args .+                                  Fullfilled "_backward_broadcast_maximum(ndarray)" args =>+                                  [NDArrayHandle] ->+                                    ArgsHMap "_backward_broadcast_maximum(ndarray)" args -> IO ()+_backward_broadcast_maximum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_maximum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_minimum(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_minimum ::+                  forall args . Fullfilled "broadcast_minimum(ndarray)" args =>+                    ArgsHMap "broadcast_minimum(ndarray)" args -> IO [NDArrayHandle]+broadcast_minimum args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_minimum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_minimum_upd ::+                      forall args . Fullfilled "broadcast_minimum(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "broadcast_minimum(ndarray)" args -> IO ()+broadcast_minimum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_minimum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_broadcast_minimum(ndarray)"+     = '[]++_backward_broadcast_minimum ::+                            forall args .+                              Fullfilled "_backward_broadcast_minimum(ndarray)" args =>+                              ArgsHMap "_backward_broadcast_minimum(ndarray)" args ->+                                IO [NDArrayHandle]+_backward_broadcast_minimum args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_minimum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_broadcast_minimum_upd ::+                                forall args .+                                  Fullfilled "_backward_broadcast_minimum(ndarray)" args =>+                                  [NDArrayHandle] ->+                                    ArgsHMap "_backward_broadcast_minimum(ndarray)" args -> IO ()+_backward_broadcast_minimum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_minimum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_hypot(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_hypot ::+                forall args . Fullfilled "broadcast_hypot(ndarray)" args =>+                  ArgsHMap "broadcast_hypot(ndarray)" args -> IO [NDArrayHandle]+broadcast_hypot args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_hypot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_hypot_upd ::+                    forall args . Fullfilled "broadcast_hypot(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "broadcast_hypot(ndarray)" args -> IO ()+broadcast_hypot_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_hypot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_broadcast_hypot(ndarray)" =+     '[]++_backward_broadcast_hypot ::+                          forall args .+                            Fullfilled "_backward_broadcast_hypot(ndarray)" args =>+                            ArgsHMap "_backward_broadcast_hypot(ndarray)" args ->+                              IO [NDArrayHandle]+_backward_broadcast_hypot args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_hypot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_broadcast_hypot_upd ::+                              forall args .+                                Fullfilled "_backward_broadcast_hypot(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_backward_broadcast_hypot(ndarray)" args -> IO ()+_backward_broadcast_hypot_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_hypot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_equal(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_equal ::+       forall args . Fullfilled "_equal(ndarray)" args =>+         ArgsHMap "_equal(ndarray)" args -> IO [NDArrayHandle]+_equal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_equal_upd ::+           forall args . Fullfilled "_equal(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "_equal(ndarray)" args -> IO ()+_equal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_not_equal(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_not_equal ::+           forall args . Fullfilled "_not_equal(ndarray)" args =>+             ArgsHMap "_not_equal(ndarray)" args -> IO [NDArrayHandle]+_not_equal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_not_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_not_equal_upd ::+               forall args . Fullfilled "_not_equal(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "_not_equal(ndarray)" args -> IO ()+_not_equal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_not_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_greater(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_greater ::+         forall args . Fullfilled "_greater(ndarray)" args =>+           ArgsHMap "_greater(ndarray)" args -> IO [NDArrayHandle]+_greater args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_greater_upd ::+             forall args . Fullfilled "_greater(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "_greater(ndarray)" args -> IO ()+_greater_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_greater_equal(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_greater_equal ::+               forall args . Fullfilled "_greater_equal(ndarray)" args =>+                 ArgsHMap "_greater_equal(ndarray)" args -> IO [NDArrayHandle]+_greater_equal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_greater_equal_upd ::+                   forall args . Fullfilled "_greater_equal(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_greater_equal(ndarray)" args -> IO ()+_greater_equal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_lesser(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_lesser ::+        forall args . Fullfilled "_lesser(ndarray)" args =>+          ArgsHMap "_lesser(ndarray)" args -> IO [NDArrayHandle]+_lesser args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_lesser_upd ::+            forall args . Fullfilled "_lesser(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "_lesser(ndarray)" args -> IO ()+_lesser_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_lesser_equal(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_lesser_equal ::+              forall args . Fullfilled "_lesser_equal(ndarray)" args =>+                ArgsHMap "_lesser_equal(ndarray)" args -> IO [NDArrayHandle]+_lesser_equal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_lesser_equal_upd ::+                  forall args . Fullfilled "_lesser_equal(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_lesser_equal(ndarray)" args -> IO ()+_lesser_equal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_logical_and(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_logical_and ::+             forall args . Fullfilled "_logical_and(ndarray)" args =>+               ArgsHMap "_logical_and(ndarray)" args -> IO [NDArrayHandle]+_logical_and args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_and"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_logical_and_upd ::+                 forall args . Fullfilled "_logical_and(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_logical_and(ndarray)" args -> IO ()+_logical_and_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_and"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_logical_or(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_logical_or ::+            forall args . Fullfilled "_logical_or(ndarray)" args =>+              ArgsHMap "_logical_or(ndarray)" args -> IO [NDArrayHandle]+_logical_or args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_or"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_logical_or_upd ::+                forall args . Fullfilled "_logical_or(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_logical_or(ndarray)" args -> IO ()+_logical_or_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_or"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_logical_xor(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_logical_xor ::+             forall args . Fullfilled "_logical_xor(ndarray)" args =>+               ArgsHMap "_logical_xor(ndarray)" args -> IO [NDArrayHandle]+_logical_xor args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_xor"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_logical_xor_upd ::+                 forall args . Fullfilled "_logical_xor(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_logical_xor(ndarray)" args -> IO ()+_logical_xor_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_xor"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_power(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_power ::+       forall args . Fullfilled "_power(ndarray)" args =>+         ArgsHMap "_power(ndarray)" args -> IO [NDArrayHandle]+_power args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_power"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_power_upd ::+           forall args . Fullfilled "_power(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "_power(ndarray)" args -> IO ()+_power_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_power"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_power(ndarray)" = '[]++_backward_power ::+                forall args . Fullfilled "_backward_power(ndarray)" args =>+                  ArgsHMap "_backward_power(ndarray)" args -> IO [NDArrayHandle]+_backward_power args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_power"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_power_upd ::+                    forall args . Fullfilled "_backward_power(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_power(ndarray)" args -> IO ()+_backward_power_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_power"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_maximum(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_maximum ::+         forall args . Fullfilled "_maximum(ndarray)" args =>+           ArgsHMap "_maximum(ndarray)" args -> IO [NDArrayHandle]+_maximum args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_maximum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_maximum_upd ::+             forall args . Fullfilled "_maximum(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "_maximum(ndarray)" args -> IO ()+_maximum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_maximum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_maximum(ndarray)" = '[]++_backward_maximum ::+                  forall args . Fullfilled "_backward_maximum(ndarray)" args =>+                    ArgsHMap "_backward_maximum(ndarray)" args -> IO [NDArrayHandle]+_backward_maximum args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_maximum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_maximum_upd ::+                      forall args . Fullfilled "_backward_maximum(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_maximum(ndarray)" args -> IO ()+_backward_maximum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_maximum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_minimum(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_minimum ::+         forall args . Fullfilled "_minimum(ndarray)" args =>+           ArgsHMap "_minimum(ndarray)" args -> IO [NDArrayHandle]+_minimum args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minimum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_minimum_upd ::+             forall args . Fullfilled "_minimum(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "_minimum(ndarray)" args -> IO ()+_minimum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minimum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_minimum(ndarray)" = '[]++_backward_minimum ::+                  forall args . Fullfilled "_backward_minimum(ndarray)" args =>+                    ArgsHMap "_backward_minimum(ndarray)" args -> IO [NDArrayHandle]+_backward_minimum args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_minimum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_minimum_upd ::+                      forall args . Fullfilled "_backward_minimum(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_minimum(ndarray)" args -> IO ()+_backward_minimum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_minimum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_hypot(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_hypot ::+       forall args . Fullfilled "_hypot(ndarray)" args =>+         ArgsHMap "_hypot(ndarray)" args -> IO [NDArrayHandle]+_hypot args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_hypot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_hypot_upd ::+           forall args . Fullfilled "_hypot(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "_hypot(ndarray)" args -> IO ()+_hypot_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_hypot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_hypot(ndarray)" = '[]++_backward_hypot ::+                forall args . Fullfilled "_backward_hypot(ndarray)" args =>+                  ArgsHMap "_backward_hypot(ndarray)" args -> IO [NDArrayHandle]+_backward_hypot args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_hypot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_hypot_upd ::+                    forall args . Fullfilled "_backward_hypot(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_hypot(ndarray)" args -> IO ()+_backward_hypot_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_hypot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_square_sum(ndarray)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++_square_sum ::+            forall args . Fullfilled "_square_sum(ndarray)" args =>+              ArgsHMap "_square_sum(ndarray)" args -> IO [NDArrayHandle]+_square_sum args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_square_sum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_square_sum_upd ::+                forall args . Fullfilled "_square_sum(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_square_sum(ndarray)" args -> IO ()+_square_sum_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_square_sum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_square_sum(ndarray)" = '[]++_backward_square_sum ::+                     forall args . Fullfilled "_backward_square_sum(ndarray)" args =>+                       ArgsHMap "_backward_square_sum(ndarray)" args -> IO [NDArrayHandle]+_backward_square_sum args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_square_sum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_square_sum_upd ::+                         forall args . Fullfilled "_backward_square_sum(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_square_sum(ndarray)" args -> IO ()+_backward_square_sum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_square_sum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "add_n(ndarray)" =+     '[ '("args", AttrOpt [NDArrayHandle])]++add_n ::+      forall args . Fullfilled "add_n(ndarray)" args =>+        ArgsHMap "add_n(ndarray)" args -> IO [NDArrayHandle]+add_n args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "add_n"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        Nothing+         return listndarr++add_n_upd ::+          forall args . Fullfilled "add_n(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "add_n(ndarray)" args -> IO ()+add_n_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "add_n"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        (Just outputs)+         return ()++type instance ParameterList "_zeros_without_dtype(ndarray)" =+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype", AttrOpt Int)]++_zeros_without_dtype ::+                     forall args . Fullfilled "_zeros_without_dtype(ndarray)" args =>+                       ArgsHMap "_zeros_without_dtype(ndarray)" args -> IO [NDArrayHandle]+_zeros_without_dtype args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$> (args !? #dtype :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_zeros_without_dtype"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_zeros_without_dtype_upd ::+                         forall args . Fullfilled "_zeros_without_dtype(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_zeros_without_dtype(ndarray)" args -> IO ()+_zeros_without_dtype_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$> (args !? #dtype :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_zeros_without_dtype"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_zeros(ndarray)" =+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"]))]++_zeros ::+       forall args . Fullfilled "_zeros(ndarray)" args =>+         ArgsHMap "_zeros(ndarray)" args -> IO [NDArrayHandle]+_zeros args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_zeros"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_zeros_upd ::+           forall args . Fullfilled "_zeros(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "_zeros(ndarray)" args -> IO ()+_zeros_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_zeros"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_eye(ndarray)" =+     '[ '("_N", AttrReq Int), '("_M", AttrOpt Int), '("k", AttrOpt Int),+        '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"]))]++_eye ::+     forall args . Fullfilled "_eye(ndarray)" args =>+       ArgsHMap "_eye(ndarray)" args -> IO [NDArrayHandle]+_eye args+  = let scalarArgs+          = catMaybes+              [("_N",) . showValue <$> (args !? #_N :: Maybe Int),+               ("_M",) . showValue <$> (args !? #_M :: Maybe Int),+               ("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_eye"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_eye_upd ::+         forall args . Fullfilled "_eye(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "_eye(ndarray)" args -> IO ()+_eye_upd outputs args+  = let scalarArgs+          = catMaybes+              [("_N",) . showValue <$> (args !? #_N :: Maybe Int),+               ("_M",) . showValue <$> (args !? #_M :: Maybe Int),+               ("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_eye"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_ones(ndarray)" =+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"]))]++_ones ::+      forall args . Fullfilled "_ones(ndarray)" args =>+        ArgsHMap "_ones(ndarray)" args -> IO [NDArrayHandle]+_ones args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_ones"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_ones_upd ::+          forall args . Fullfilled "_ones(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "_ones(ndarray)" args -> IO ()+_ones_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_ones"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_full(ndarray)" =+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("value", AttrReq Double)]++_full ::+      forall args . Fullfilled "_full(ndarray)" args =>+        ArgsHMap "_full(ndarray)" args -> IO [NDArrayHandle]+_full args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"])),+               ("value",) . showValue <$> (args !? #value :: Maybe Double)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_full"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_full_upd ::+          forall args . Fullfilled "_full(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "_full(ndarray)" args -> IO ()+_full_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"])),+               ("value",) . showValue <$> (args !? #value :: Maybe Double)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_full"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_arange(ndarray)" =+     '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)),+        '("step", AttrOpt Double), '("repeat", AttrOpt Int),+        '("infer_range", AttrOpt Bool), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"]))]++_arange ::+        forall args . Fullfilled "_arange(ndarray)" args =>+          ArgsHMap "_arange(ndarray)" args -> IO [NDArrayHandle]+_arange args+  = let scalarArgs+          = catMaybes+              [("start",) . showValue <$> (args !? #start :: Maybe Double),+               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),+               ("step",) . showValue <$> (args !? #step :: Maybe Double),+               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),+               ("infer_range",) . showValue <$>+                 (args !? #infer_range :: Maybe Bool),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_arange"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_arange_upd ::+            forall args . Fullfilled "_arange(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "_arange(ndarray)" args -> IO ()+_arange_upd outputs args+  = let scalarArgs+          = catMaybes+              [("start",) . showValue <$> (args !? #start :: Maybe Double),+               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),+               ("step",) . showValue <$> (args !? #step :: Maybe Double),+               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),+               ("infer_range",) . showValue <$>+                 (args !? #infer_range :: Maybe Bool),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_arange"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linspace(ndarray)" =+     '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)),+        '("step", AttrOpt Double), '("repeat", AttrOpt Int),+        '("infer_range", AttrOpt Bool), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"]))]++_linspace ::+          forall args . Fullfilled "_linspace(ndarray)" args =>+            ArgsHMap "_linspace(ndarray)" args -> IO [NDArrayHandle]+_linspace args+  = let scalarArgs+          = catMaybes+              [("start",) . showValue <$> (args !? #start :: Maybe Double),+               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),+               ("step",) . showValue <$> (args !? #step :: Maybe Double),+               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),+               ("infer_range",) . showValue <$>+                 (args !? #infer_range :: Maybe Bool),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linspace"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linspace_upd ::+              forall args . Fullfilled "_linspace(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "_linspace(ndarray)" args -> IO ()+_linspace_upd outputs args+  = let scalarArgs+          = catMaybes+              [("start",) . showValue <$> (args !? #start :: Maybe Double),+               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),+               ("step",) . showValue <$> (args !? #step :: Maybe Double),+               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),+               ("infer_range",) . showValue <$>+                 (args !? #infer_range :: Maybe Bool),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linspace"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "zeros_like(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++zeros_like ::+           forall args . Fullfilled "zeros_like(ndarray)" args =>+             ArgsHMap "zeros_like(ndarray)" args -> IO [NDArrayHandle]+zeros_like args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "zeros_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++zeros_like_upd ::+               forall args . Fullfilled "zeros_like(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "zeros_like(ndarray)" args -> IO ()+zeros_like_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "zeros_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "ones_like(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++ones_like ::+          forall args . Fullfilled "ones_like(ndarray)" args =>+            ArgsHMap "ones_like(ndarray)" args -> IO [NDArrayHandle]+ones_like args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ones_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++ones_like_upd ::+              forall args . Fullfilled "ones_like(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "ones_like(ndarray)" args -> IO ()+ones_like_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ones_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_add(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_add ::+              forall args . Fullfilled "broadcast_add(ndarray)" args =>+                ArgsHMap "broadcast_add(ndarray)" args -> IO [NDArrayHandle]+broadcast_add args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_add_upd ::+                  forall args . Fullfilled "broadcast_add(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "broadcast_add(ndarray)" args -> IO ()+broadcast_add_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_broadcast_add(ndarray)" =+     '[]++_backward_broadcast_add ::+                        forall args . Fullfilled "_backward_broadcast_add(ndarray)" args =>+                          ArgsHMap "_backward_broadcast_add(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_broadcast_add args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_broadcast_add_upd ::+                            forall args . Fullfilled "_backward_broadcast_add(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_broadcast_add(ndarray)" args -> IO ()+_backward_broadcast_add_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_sub(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_sub ::+              forall args . Fullfilled "broadcast_sub(ndarray)" args =>+                ArgsHMap "broadcast_sub(ndarray)" args -> IO [NDArrayHandle]+broadcast_sub args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_sub"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_sub_upd ::+                  forall args . Fullfilled "broadcast_sub(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "broadcast_sub(ndarray)" args -> IO ()+broadcast_sub_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_sub"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_broadcast_sub(ndarray)" =+     '[]++_backward_broadcast_sub ::+                        forall args . Fullfilled "_backward_broadcast_sub(ndarray)" args =>+                          ArgsHMap "_backward_broadcast_sub(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_broadcast_sub args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_sub"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_broadcast_sub_upd ::+                            forall args . Fullfilled "_backward_broadcast_sub(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_broadcast_sub(ndarray)" args -> IO ()+_backward_broadcast_sub_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_sub"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_mul(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_mul ::+              forall args . Fullfilled "broadcast_mul(ndarray)" args =>+                ArgsHMap "broadcast_mul(ndarray)" args -> IO [NDArrayHandle]+broadcast_mul args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_mul"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_mul_upd ::+                  forall args . Fullfilled "broadcast_mul(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "broadcast_mul(ndarray)" args -> IO ()+broadcast_mul_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_mul"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_broadcast_mul(ndarray)" =+     '[]++_backward_broadcast_mul ::+                        forall args . Fullfilled "_backward_broadcast_mul(ndarray)" args =>+                          ArgsHMap "_backward_broadcast_mul(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_broadcast_mul args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_mul"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_broadcast_mul_upd ::+                            forall args . Fullfilled "_backward_broadcast_mul(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_broadcast_mul(ndarray)" args -> IO ()+_backward_broadcast_mul_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_mul"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_div(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_div ::+              forall args . Fullfilled "broadcast_div(ndarray)" args =>+                ArgsHMap "broadcast_div(ndarray)" args -> IO [NDArrayHandle]+broadcast_div args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_div_upd ::+                  forall args . Fullfilled "broadcast_div(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "broadcast_div(ndarray)" args -> IO ()+broadcast_div_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_broadcast_div(ndarray)" =+     '[]++_backward_broadcast_div ::+                        forall args . Fullfilled "_backward_broadcast_div(ndarray)" args =>+                          ArgsHMap "_backward_broadcast_div(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_broadcast_div args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_broadcast_div_upd ::+                            forall args . Fullfilled "_backward_broadcast_div(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_broadcast_div(ndarray)" args -> IO ()+_backward_broadcast_div_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_mod(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_mod ::+              forall args . Fullfilled "broadcast_mod(ndarray)" args =>+                ArgsHMap "broadcast_mod(ndarray)" args -> IO [NDArrayHandle]+broadcast_mod args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_mod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_mod_upd ::+                  forall args . Fullfilled "broadcast_mod(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "broadcast_mod(ndarray)" args -> IO ()+broadcast_mod_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_mod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_broadcast_mod(ndarray)" =+     '[]++_backward_broadcast_mod ::+                        forall args . Fullfilled "_backward_broadcast_mod(ndarray)" args =>+                          ArgsHMap "_backward_broadcast_mod(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_broadcast_mod args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_mod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_broadcast_mod_upd ::+                            forall args . Fullfilled "_backward_broadcast_mod(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_broadcast_mod(ndarray)" args -> IO ()+_backward_broadcast_mod_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_mod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_gemm(ndarray)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("alpha", AttrOpt Double), '("beta", AttrOpt Double),+        '("axis", AttrOpt Int), '("_A", AttrOpt NDArrayHandle),+        '("_B", AttrOpt NDArrayHandle), '("_C", AttrOpt NDArrayHandle)]++_linalg_gemm ::+             forall args . Fullfilled "_linalg_gemm(ndarray)" args =>+               ArgsHMap "_linalg_gemm(ndarray)" args -> IO [NDArrayHandle]+_linalg_gemm args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Double),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),+               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle),+               ("_C",) <$> (args !? #_C :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gemm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_gemm_upd ::+                 forall args . Fullfilled "_linalg_gemm(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_linalg_gemm(ndarray)" args -> IO ()+_linalg_gemm_upd outputs args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Double),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),+               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle),+               ("_C",) <$> (args !? #_C :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gemm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_gemm(ndarray)" = '[]++_backward_linalg_gemm ::+                      forall args . Fullfilled "_backward_linalg_gemm(ndarray)" args =>+                        ArgsHMap "_backward_linalg_gemm(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_linalg_gemm args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gemm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_gemm_upd ::+                          forall args . Fullfilled "_backward_linalg_gemm(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_linalg_gemm(ndarray)" args -> IO ()+_backward_linalg_gemm_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gemm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_gemm2(ndarray)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("alpha", AttrOpt Double), '("axis", AttrOpt Int),+        '("_A", AttrOpt NDArrayHandle), '("_B", AttrOpt NDArrayHandle)]++_linalg_gemm2 ::+              forall args . Fullfilled "_linalg_gemm2(ndarray)" args =>+                ArgsHMap "_linalg_gemm2(ndarray)" args -> IO [NDArrayHandle]+_linalg_gemm2 args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),+               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gemm2"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_gemm2_upd ::+                  forall args . Fullfilled "_linalg_gemm2(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_linalg_gemm2(ndarray)" args -> IO ()+_linalg_gemm2_upd outputs args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),+               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gemm2"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_gemm2(ndarray)" = '[]++_backward_linalg_gemm2 ::+                       forall args . Fullfilled "_backward_linalg_gemm2(ndarray)" args =>+                         ArgsHMap "_backward_linalg_gemm2(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_linalg_gemm2 args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gemm2"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_gemm2_upd ::+                           forall args . Fullfilled "_backward_linalg_gemm2(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_linalg_gemm2(ndarray)" args -> IO ()+_backward_linalg_gemm2_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gemm2"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_potrf(ndarray)" =+     '[ '("_A", AttrOpt NDArrayHandle)]++_linalg_potrf ::+              forall args . Fullfilled "_linalg_potrf(ndarray)" args =>+                ArgsHMap "_linalg_potrf(ndarray)" args -> IO [NDArrayHandle]+_linalg_potrf args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_potrf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_potrf_upd ::+                  forall args . Fullfilled "_linalg_potrf(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_linalg_potrf(ndarray)" args -> IO ()+_linalg_potrf_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_potrf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_potrf(ndarray)" = '[]++_backward_linalg_potrf ::+                       forall args . Fullfilled "_backward_linalg_potrf(ndarray)" args =>+                         ArgsHMap "_backward_linalg_potrf(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_linalg_potrf args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_potrf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_potrf_upd ::+                           forall args . Fullfilled "_backward_linalg_potrf(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_linalg_potrf(ndarray)" args -> IO ()+_backward_linalg_potrf_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_potrf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_potri(ndarray)" =+     '[ '("_A", AttrOpt NDArrayHandle)]++_linalg_potri ::+              forall args . Fullfilled "_linalg_potri(ndarray)" args =>+                ArgsHMap "_linalg_potri(ndarray)" args -> IO [NDArrayHandle]+_linalg_potri args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_potri"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_potri_upd ::+                  forall args . Fullfilled "_linalg_potri(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_linalg_potri(ndarray)" args -> IO ()+_linalg_potri_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_potri"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_potri(ndarray)" = '[]++_backward_linalg_potri ::+                       forall args . Fullfilled "_backward_linalg_potri(ndarray)" args =>+                         ArgsHMap "_backward_linalg_potri(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_linalg_potri args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_potri"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_potri_upd ::+                           forall args . Fullfilled "_backward_linalg_potri(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_linalg_potri(ndarray)" args -> IO ()+_backward_linalg_potri_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_potri"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_trmm(ndarray)" =+     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),+        '("lower", AttrOpt Bool), '("alpha", AttrOpt Double),+        '("_A", AttrOpt NDArrayHandle), '("_B", AttrOpt NDArrayHandle)]++_linalg_trmm ::+             forall args . Fullfilled "_linalg_trmm(ndarray)" args =>+               ArgsHMap "_linalg_trmm(ndarray)" args -> IO [NDArrayHandle]+_linalg_trmm args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),+               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),+               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_trmm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_trmm_upd ::+                 forall args . Fullfilled "_linalg_trmm(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_linalg_trmm(ndarray)" args -> IO ()+_linalg_trmm_upd outputs args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),+               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),+               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_trmm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_trmm(ndarray)" = '[]++_backward_linalg_trmm ::+                      forall args . Fullfilled "_backward_linalg_trmm(ndarray)" args =>+                        ArgsHMap "_backward_linalg_trmm(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_linalg_trmm args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_trmm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_trmm_upd ::+                          forall args . Fullfilled "_backward_linalg_trmm(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_linalg_trmm(ndarray)" args -> IO ()+_backward_linalg_trmm_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_trmm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_trsm(ndarray)" =+     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),+        '("lower", AttrOpt Bool), '("alpha", AttrOpt Double),+        '("_A", AttrOpt NDArrayHandle), '("_B", AttrOpt NDArrayHandle)]++_linalg_trsm ::+             forall args . Fullfilled "_linalg_trsm(ndarray)" args =>+               ArgsHMap "_linalg_trsm(ndarray)" args -> IO [NDArrayHandle]+_linalg_trsm args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),+               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),+               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_trsm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_trsm_upd ::+                 forall args . Fullfilled "_linalg_trsm(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_linalg_trsm(ndarray)" args -> IO ()+_linalg_trsm_upd outputs args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),+               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),+               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_trsm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_trsm(ndarray)" = '[]++_backward_linalg_trsm ::+                      forall args . Fullfilled "_backward_linalg_trsm(ndarray)" args =>+                        ArgsHMap "_backward_linalg_trsm(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_linalg_trsm args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_trsm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_trsm_upd ::+                          forall args . Fullfilled "_backward_linalg_trsm(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_linalg_trsm(ndarray)" args -> IO ()+_backward_linalg_trsm_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_trsm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_sumlogdiag(ndarray)" =+     '[ '("_A", AttrOpt NDArrayHandle)]++_linalg_sumlogdiag ::+                   forall args . Fullfilled "_linalg_sumlogdiag(ndarray)" args =>+                     ArgsHMap "_linalg_sumlogdiag(ndarray)" args -> IO [NDArrayHandle]+_linalg_sumlogdiag args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_sumlogdiag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_sumlogdiag_upd ::+                       forall args . Fullfilled "_linalg_sumlogdiag(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_linalg_sumlogdiag(ndarray)" args -> IO ()+_linalg_sumlogdiag_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_sumlogdiag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_sumlogdiag(ndarray)"+     = '[]++_backward_linalg_sumlogdiag ::+                            forall args .+                              Fullfilled "_backward_linalg_sumlogdiag(ndarray)" args =>+                              ArgsHMap "_backward_linalg_sumlogdiag(ndarray)" args ->+                                IO [NDArrayHandle]+_backward_linalg_sumlogdiag args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_sumlogdiag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_sumlogdiag_upd ::+                                forall args .+                                  Fullfilled "_backward_linalg_sumlogdiag(ndarray)" args =>+                                  [NDArrayHandle] ->+                                    ArgsHMap "_backward_linalg_sumlogdiag(ndarray)" args -> IO ()+_backward_linalg_sumlogdiag_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_sumlogdiag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_extractdiag(ndarray)" =+     '[ '("offset", AttrOpt Int), '("_A", AttrOpt NDArrayHandle)]++_linalg_extractdiag ::+                    forall args . Fullfilled "_linalg_extractdiag(ndarray)" args =>+                      ArgsHMap "_linalg_extractdiag(ndarray)" args -> IO [NDArrayHandle]+_linalg_extractdiag args+  = let scalarArgs+          = catMaybes+              [("offset",) . showValue <$> (args !? #offset :: Maybe Int)]+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_extractdiag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_extractdiag_upd ::+                        forall args . Fullfilled "_linalg_extractdiag(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_linalg_extractdiag(ndarray)" args -> IO ()+_linalg_extractdiag_upd outputs args+  = let scalarArgs+          = catMaybes+              [("offset",) . showValue <$> (args !? #offset :: Maybe Int)]+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_extractdiag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_extractdiag(ndarray)"+     = '[]++_backward_linalg_extractdiag ::+                             forall args .+                               Fullfilled "_backward_linalg_extractdiag(ndarray)" args =>+                               ArgsHMap "_backward_linalg_extractdiag(ndarray)" args ->+                                 IO [NDArrayHandle]+_backward_linalg_extractdiag args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_extractdiag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_extractdiag_upd ::+                                 forall args .+                                   Fullfilled "_backward_linalg_extractdiag(ndarray)" args =>+                                   [NDArrayHandle] ->+                                     ArgsHMap "_backward_linalg_extractdiag(ndarray)" args -> IO ()+_backward_linalg_extractdiag_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_extractdiag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_makediag(ndarray)" =+     '[ '("offset", AttrOpt Int), '("_A", AttrOpt NDArrayHandle)]++_linalg_makediag ::+                 forall args . Fullfilled "_linalg_makediag(ndarray)" args =>+                   ArgsHMap "_linalg_makediag(ndarray)" args -> IO [NDArrayHandle]+_linalg_makediag args+  = let scalarArgs+          = catMaybes+              [("offset",) . showValue <$> (args !? #offset :: Maybe Int)]+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_makediag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_makediag_upd ::+                     forall args . Fullfilled "_linalg_makediag(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_linalg_makediag(ndarray)" args -> IO ()+_linalg_makediag_upd outputs args+  = let scalarArgs+          = catMaybes+              [("offset",) . showValue <$> (args !? #offset :: Maybe Int)]+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_makediag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_makediag(ndarray)" =+     '[]++_backward_linalg_makediag ::+                          forall args .+                            Fullfilled "_backward_linalg_makediag(ndarray)" args =>+                            ArgsHMap "_backward_linalg_makediag(ndarray)" args ->+                              IO [NDArrayHandle]+_backward_linalg_makediag args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_makediag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_makediag_upd ::+                              forall args .+                                Fullfilled "_backward_linalg_makediag(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_backward_linalg_makediag(ndarray)" args -> IO ()+_backward_linalg_makediag_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_makediag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_extracttrian(ndarray)" =+     '[ '("offset", AttrOpt Int), '("lower", AttrOpt Bool),+        '("_A", AttrOpt NDArrayHandle)]++_linalg_extracttrian ::+                     forall args . Fullfilled "_linalg_extracttrian(ndarray)" args =>+                       ArgsHMap "_linalg_extracttrian(ndarray)" args -> IO [NDArrayHandle]+_linalg_extracttrian args+  = let scalarArgs+          = catMaybes+              [("offset",) . showValue <$> (args !? #offset :: Maybe Int),+               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool)]+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_extracttrian"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_extracttrian_upd ::+                         forall args . Fullfilled "_linalg_extracttrian(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_linalg_extracttrian(ndarray)" args -> IO ()+_linalg_extracttrian_upd outputs args+  = let scalarArgs+          = catMaybes+              [("offset",) . showValue <$> (args !? #offset :: Maybe Int),+               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool)]+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_extracttrian"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward_linalg_extracttrian(ndarray)" = '[]++_backward_linalg_extracttrian ::+                              forall args .+                                Fullfilled "_backward_linalg_extracttrian(ndarray)" args =>+                                ArgsHMap "_backward_linalg_extracttrian(ndarray)" args ->+                                  IO [NDArrayHandle]+_backward_linalg_extracttrian args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_extracttrian"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_extracttrian_upd ::+                                  forall args .+                                    Fullfilled "_backward_linalg_extracttrian(ndarray)" args =>+                                    [NDArrayHandle] ->+                                      ArgsHMap "_backward_linalg_extracttrian(ndarray)" args ->+                                        IO ()+_backward_linalg_extracttrian_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_extracttrian"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_maketrian(ndarray)" =+     '[ '("offset", AttrOpt Int), '("lower", AttrOpt Bool),+        '("_A", AttrOpt NDArrayHandle)]++_linalg_maketrian ::+                  forall args . Fullfilled "_linalg_maketrian(ndarray)" args =>+                    ArgsHMap "_linalg_maketrian(ndarray)" args -> IO [NDArrayHandle]+_linalg_maketrian args+  = let scalarArgs+          = catMaybes+              [("offset",) . showValue <$> (args !? #offset :: Maybe Int),+               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool)]+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_maketrian"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_maketrian_upd ::+                      forall args . Fullfilled "_linalg_maketrian(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_linalg_maketrian(ndarray)" args -> IO ()+_linalg_maketrian_upd outputs args+  = let scalarArgs+          = catMaybes+              [("offset",) . showValue <$> (args !? #offset :: Maybe Int),+               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool)]+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_maketrian"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_maketrian(ndarray)" =+     '[]++_backward_linalg_maketrian ::+                           forall args .+                             Fullfilled "_backward_linalg_maketrian(ndarray)" args =>+                             ArgsHMap "_backward_linalg_maketrian(ndarray)" args ->+                               IO [NDArrayHandle]+_backward_linalg_maketrian args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_maketrian"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_maketrian_upd ::+                               forall args .+                                 Fullfilled "_backward_linalg_maketrian(ndarray)" args =>+                                 [NDArrayHandle] ->+                                   ArgsHMap "_backward_linalg_maketrian(ndarray)" args -> IO ()+_backward_linalg_maketrian_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_maketrian"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_syrk(ndarray)" =+     '[ '("transpose", AttrOpt Bool), '("alpha", AttrOpt Double),+        '("_A", AttrOpt NDArrayHandle)]++_linalg_syrk ::+             forall args . Fullfilled "_linalg_syrk(ndarray)" args =>+               ArgsHMap "_linalg_syrk(ndarray)" args -> IO [NDArrayHandle]+_linalg_syrk args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_syrk"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_syrk_upd ::+                 forall args . Fullfilled "_linalg_syrk(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_linalg_syrk(ndarray)" args -> IO ()+_linalg_syrk_upd outputs args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_syrk"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_syrk(ndarray)" = '[]++_backward_linalg_syrk ::+                      forall args . Fullfilled "_backward_linalg_syrk(ndarray)" args =>+                        ArgsHMap "_backward_linalg_syrk(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_linalg_syrk args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_syrk"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_syrk_upd ::+                          forall args . Fullfilled "_backward_linalg_syrk(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_linalg_syrk(ndarray)" args -> IO ()+_backward_linalg_syrk_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_syrk"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_gelqf(ndarray)" =+     '[ '("_A", AttrOpt NDArrayHandle)]++_linalg_gelqf ::+              forall args . Fullfilled "_linalg_gelqf(ndarray)" args =>+                ArgsHMap "_linalg_gelqf(ndarray)" args -> IO [NDArrayHandle]+_linalg_gelqf args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gelqf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_gelqf_upd ::+                  forall args . Fullfilled "_linalg_gelqf(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_linalg_gelqf(ndarray)" args -> IO ()+_linalg_gelqf_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gelqf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_gelqf(ndarray)" = '[]++_backward_linalg_gelqf ::+                       forall args . Fullfilled "_backward_linalg_gelqf(ndarray)" args =>+                         ArgsHMap "_backward_linalg_gelqf(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_linalg_gelqf args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gelqf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_gelqf_upd ::+                           forall args . Fullfilled "_backward_linalg_gelqf(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_linalg_gelqf(ndarray)" args -> IO ()+_backward_linalg_gelqf_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gelqf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_syevd(ndarray)" =+     '[ '("_A", AttrOpt NDArrayHandle)]++_linalg_syevd ::+              forall args . Fullfilled "_linalg_syevd(ndarray)" args =>+                ArgsHMap "_linalg_syevd(ndarray)" args -> IO [NDArrayHandle]+_linalg_syevd args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_syevd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_syevd_upd ::+                  forall args . Fullfilled "_linalg_syevd(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_linalg_syevd(ndarray)" args -> IO ()+_linalg_syevd_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_syevd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_syevd(ndarray)" = '[]++_backward_linalg_syevd ::+                       forall args . Fullfilled "_backward_linalg_syevd(ndarray)" args =>+                         ArgsHMap "_backward_linalg_syevd(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_linalg_syevd args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_syevd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_syevd_upd ::+                           forall args . Fullfilled "_backward_linalg_syevd(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_linalg_syevd(ndarray)" args -> IO ()+_backward_linalg_syevd_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_syevd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_linalg_inverse(ndarray)" =+     '[ '("_A", AttrOpt NDArrayHandle)]++_linalg_inverse ::+                forall args . Fullfilled "_linalg_inverse(ndarray)" args =>+                  ArgsHMap "_linalg_inverse(ndarray)" args -> IO [NDArrayHandle]+_linalg_inverse args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_inverse"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_linalg_inverse_upd ::+                    forall args . Fullfilled "_linalg_inverse(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_linalg_inverse(ndarray)" args -> IO ()+_linalg_inverse_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_inverse"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linalg_inverse(ndarray)" =+     '[]++_backward_linalg_inverse ::+                         forall args .+                           Fullfilled "_backward_linalg_inverse(ndarray)" args =>+                           ArgsHMap "_backward_linalg_inverse(ndarray)" args ->+                             IO [NDArrayHandle]+_backward_linalg_inverse args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_inverse"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linalg_inverse_upd ::+                             forall args .+                               Fullfilled "_backward_linalg_inverse(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_backward_linalg_inverse(ndarray)" args -> IO ()+_backward_linalg_inverse_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_inverse"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_histogram(ndarray)" =+     '[ '("bin_cnt", AttrOpt (Maybe Int)), '("range", AttrOpt Int),+        '("data", AttrOpt NDArrayHandle), '("bins", AttrOpt NDArrayHandle)]++_histogram ::+           forall args . Fullfilled "_histogram(ndarray)" args =>+             ArgsHMap "_histogram(ndarray)" args -> IO [NDArrayHandle]+_histogram args+  = let scalarArgs+          = catMaybes+              [("bin_cnt",) . showValue <$>+                 (args !? #bin_cnt :: Maybe (Maybe Int)),+               ("range",) . showValue <$> (args !? #range :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("bins",) <$> (args !? #bins :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_histogram"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_histogram_upd ::+               forall args . Fullfilled "_histogram(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "_histogram(ndarray)" args -> IO ()+_histogram_upd outputs args+  = let scalarArgs+          = catMaybes+              [("bin_cnt",) . showValue <$>+                 (args !? #bin_cnt :: Maybe (Maybe Int)),+               ("range",) . showValue <$> (args !? #range :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("bins",) <$> (args !? #bins :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_histogram"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "cast_storage(ndarray)" =+     '[ '("stype",+          AttrReq (EnumType '["csr", "default", "row_sparse"])),+        '("data", AttrOpt NDArrayHandle)]++cast_storage ::+             forall args . Fullfilled "cast_storage(ndarray)" args =>+               ArgsHMap "cast_storage(ndarray)" args -> IO [NDArrayHandle]+cast_storage args+  = let scalarArgs+          = catMaybes+              [("stype",) . showValue <$>+                 (args !? #stype ::+                    Maybe (EnumType '["csr", "default", "row_sparse"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cast_storage"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++cast_storage_upd ::+                 forall args . Fullfilled "cast_storage(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "cast_storage(ndarray)" args -> IO ()+cast_storage_upd outputs args+  = let scalarArgs+          = catMaybes+              [("stype",) . showValue <$>+                 (args !? #stype ::+                    Maybe (EnumType '["csr", "default", "row_sparse"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cast_storage"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_equal_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_equal_scalar ::+              forall args . Fullfilled "_equal_scalar(ndarray)" args =>+                ArgsHMap "_equal_scalar(ndarray)" args -> IO [NDArrayHandle]+_equal_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_equal_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_equal_scalar_upd ::+                  forall args . Fullfilled "_equal_scalar(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_equal_scalar(ndarray)" args -> IO ()+_equal_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_equal_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_not_equal_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_not_equal_scalar ::+                  forall args . Fullfilled "_not_equal_scalar(ndarray)" args =>+                    ArgsHMap "_not_equal_scalar(ndarray)" args -> IO [NDArrayHandle]+_not_equal_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_not_equal_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_not_equal_scalar_upd ::+                      forall args . Fullfilled "_not_equal_scalar(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_not_equal_scalar(ndarray)" args -> IO ()+_not_equal_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_not_equal_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_greater_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_greater_scalar ::+                forall args . Fullfilled "_greater_scalar(ndarray)" args =>+                  ArgsHMap "_greater_scalar(ndarray)" args -> IO [NDArrayHandle]+_greater_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_greater_scalar_upd ::+                    forall args . Fullfilled "_greater_scalar(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_greater_scalar(ndarray)" args -> IO ()+_greater_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_greater_equal_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_greater_equal_scalar ::+                      forall args . Fullfilled "_greater_equal_scalar(ndarray)" args =>+                        ArgsHMap "_greater_equal_scalar(ndarray)" args ->+                          IO [NDArrayHandle]+_greater_equal_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_equal_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_greater_equal_scalar_upd ::+                          forall args . Fullfilled "_greater_equal_scalar(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_greater_equal_scalar(ndarray)" args -> IO ()+_greater_equal_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_equal_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_lesser_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_lesser_scalar ::+               forall args . Fullfilled "_lesser_scalar(ndarray)" args =>+                 ArgsHMap "_lesser_scalar(ndarray)" args -> IO [NDArrayHandle]+_lesser_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_lesser_scalar_upd ::+                   forall args . Fullfilled "_lesser_scalar(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_lesser_scalar(ndarray)" args -> IO ()+_lesser_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_lesser_equal_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_lesser_equal_scalar ::+                     forall args . Fullfilled "_lesser_equal_scalar(ndarray)" args =>+                       ArgsHMap "_lesser_equal_scalar(ndarray)" args -> IO [NDArrayHandle]+_lesser_equal_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_equal_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_lesser_equal_scalar_upd ::+                         forall args . Fullfilled "_lesser_equal_scalar(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_lesser_equal_scalar(ndarray)" args -> IO ()+_lesser_equal_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_equal_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_logical_and_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_logical_and_scalar ::+                    forall args . Fullfilled "_logical_and_scalar(ndarray)" args =>+                      ArgsHMap "_logical_and_scalar(ndarray)" args -> IO [NDArrayHandle]+_logical_and_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_and_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_logical_and_scalar_upd ::+                        forall args . Fullfilled "_logical_and_scalar(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_logical_and_scalar(ndarray)" args -> IO ()+_logical_and_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_and_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_logical_or_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_logical_or_scalar ::+                   forall args . Fullfilled "_logical_or_scalar(ndarray)" args =>+                     ArgsHMap "_logical_or_scalar(ndarray)" args -> IO [NDArrayHandle]+_logical_or_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_or_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_logical_or_scalar_upd ::+                       forall args . Fullfilled "_logical_or_scalar(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_logical_or_scalar(ndarray)" args -> IO ()+_logical_or_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_or_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_logical_xor_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_logical_xor_scalar ::+                    forall args . Fullfilled "_logical_xor_scalar(ndarray)" args =>+                      ArgsHMap "_logical_xor_scalar(ndarray)" args -> IO [NDArrayHandle]+_logical_xor_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_xor_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_logical_xor_scalar_upd ::+                        forall args . Fullfilled "_logical_xor_scalar(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_logical_xor_scalar(ndarray)" args -> IO ()+_logical_xor_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_xor_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "relu(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++relu ::+     forall args . Fullfilled "relu(ndarray)" args =>+       ArgsHMap "relu(ndarray)" args -> IO [NDArrayHandle]+relu args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "relu"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++relu_upd ::+         forall args . Fullfilled "relu(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "relu(ndarray)" args -> IO ()+relu_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "relu"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_relu(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_relu ::+               forall args . Fullfilled "_backward_relu(ndarray)" args =>+                 ArgsHMap "_backward_relu(ndarray)" args -> IO [NDArrayHandle]+_backward_relu args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_relu"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_relu_upd ::+                   forall args . Fullfilled "_backward_relu(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_relu(ndarray)" args -> IO ()+_backward_relu_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_relu"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "sigmoid(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++sigmoid ::+        forall args . Fullfilled "sigmoid(ndarray)" args =>+          ArgsHMap "sigmoid(ndarray)" args -> IO [NDArrayHandle]+sigmoid args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sigmoid"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++sigmoid_upd ::+            forall args . Fullfilled "sigmoid(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "sigmoid(ndarray)" args -> IO ()+sigmoid_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sigmoid"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_sigmoid(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_sigmoid ::+                  forall args . Fullfilled "_backward_sigmoid(ndarray)" args =>+                    ArgsHMap "_backward_sigmoid(ndarray)" args -> IO [NDArrayHandle]+_backward_sigmoid args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sigmoid"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_sigmoid_upd ::+                      forall args . Fullfilled "_backward_sigmoid(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_sigmoid(ndarray)" args -> IO ()+_backward_sigmoid_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sigmoid"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "hard_sigmoid(ndarray)" =+     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle)]++hard_sigmoid ::+             forall args . Fullfilled "hard_sigmoid(ndarray)" args =>+               ArgsHMap "hard_sigmoid(ndarray)" args -> IO [NDArrayHandle]+hard_sigmoid args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "hard_sigmoid"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++hard_sigmoid_upd ::+                 forall args . Fullfilled "hard_sigmoid(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "hard_sigmoid(ndarray)" args -> IO ()+hard_sigmoid_upd outputs args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "hard_sigmoid"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_hard_sigmoid(ndarray)" = '[]++_backward_hard_sigmoid ::+                       forall args . Fullfilled "_backward_hard_sigmoid(ndarray)" args =>+                         ArgsHMap "_backward_hard_sigmoid(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_hard_sigmoid args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_hard_sigmoid"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_hard_sigmoid_upd ::+                           forall args . Fullfilled "_backward_hard_sigmoid(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_hard_sigmoid(ndarray)" args -> IO ()+_backward_hard_sigmoid_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_hard_sigmoid"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "softsign(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++softsign ::+         forall args . Fullfilled "softsign(ndarray)" args =>+           ArgsHMap "softsign(ndarray)" args -> IO [NDArrayHandle]+softsign args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softsign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++softsign_upd ::+             forall args . Fullfilled "softsign(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "softsign(ndarray)" args -> IO ()+softsign_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softsign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_softsign(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_softsign ::+                   forall args . Fullfilled "_backward_softsign(ndarray)" args =>+                     ArgsHMap "_backward_softsign(ndarray)" args -> IO [NDArrayHandle]+_backward_softsign args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_softsign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_softsign_upd ::+                       forall args . Fullfilled "_backward_softsign(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_backward_softsign(ndarray)" args -> IO ()+_backward_softsign_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_softsign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_copy(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_copy ::+      forall args . Fullfilled "_copy(ndarray)" args =>+        ArgsHMap "_copy(ndarray)" args -> IO [NDArrayHandle]+_copy args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_copy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_copy_upd ::+          forall args . Fullfilled "_copy(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "_copy(ndarray)" args -> IO ()+_copy_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_copy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_copy(ndarray)" = '[]++_backward_copy ::+               forall args . Fullfilled "_backward_copy(ndarray)" args =>+                 ArgsHMap "_backward_copy(ndarray)" args -> IO [NDArrayHandle]+_backward_copy args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_copy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_copy_upd ::+                   forall args . Fullfilled "_backward_copy(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_copy(ndarray)" args -> IO ()+_backward_copy_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_copy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_reshape(ndarray)" = '[]++_backward_reshape ::+                  forall args . Fullfilled "_backward_reshape(ndarray)" args =>+                    ArgsHMap "_backward_reshape(ndarray)" args -> IO [NDArrayHandle]+_backward_reshape args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_reshape"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_reshape_upd ::+                      forall args . Fullfilled "_backward_reshape(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_reshape(ndarray)" args -> IO ()+_backward_reshape_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_reshape"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_BlockGrad(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_BlockGrad ::+           forall args . Fullfilled "_BlockGrad(ndarray)" args =>+             ArgsHMap "_BlockGrad(ndarray)" args -> IO [NDArrayHandle]+_BlockGrad args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BlockGrad"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_BlockGrad_upd ::+               forall args . Fullfilled "_BlockGrad(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "_BlockGrad(ndarray)" args -> IO ()+_BlockGrad_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BlockGrad"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "make_loss(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++make_loss ::+          forall args . Fullfilled "make_loss(ndarray)" args =>+            ArgsHMap "make_loss(ndarray)" args -> IO [NDArrayHandle]+make_loss args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "make_loss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++make_loss_upd ::+              forall args . Fullfilled "make_loss(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "make_loss(ndarray)" args -> IO ()+make_loss_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "make_loss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_identity_with_attr_like_rhs(ndarray)"+     =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_identity_with_attr_like_rhs ::+                             forall args .+                               Fullfilled "_identity_with_attr_like_rhs(ndarray)" args =>+                               ArgsHMap "_identity_with_attr_like_rhs(ndarray)" args ->+                                 IO [NDArrayHandle]+_identity_with_attr_like_rhs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_identity_with_attr_like_rhs"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_identity_with_attr_like_rhs_upd ::+                                 forall args .+                                   Fullfilled "_identity_with_attr_like_rhs(ndarray)" args =>+                                   [NDArrayHandle] ->+                                     ArgsHMap "_identity_with_attr_like_rhs(ndarray)" args -> IO ()+_identity_with_attr_like_rhs_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_identity_with_attr_like_rhs"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "reshape_like(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++reshape_like ::+             forall args . Fullfilled "reshape_like(ndarray)" args =>+               ArgsHMap "reshape_like(ndarray)" args -> IO [NDArrayHandle]+reshape_like args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reshape_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++reshape_like_upd ::+                 forall args . Fullfilled "reshape_like(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "reshape_like(ndarray)" args -> IO ()+reshape_like_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reshape_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "shape_array(ndarray)" =+     '[ '("lhs_begin", AttrOpt (Maybe Int)),+        '("lhs_end", AttrOpt (Maybe Int)),+        '("rhs_begin", AttrOpt (Maybe Int)),+        '("rhs_end", AttrOpt (Maybe Int)),+        '("data", AttrOpt NDArrayHandle)]++shape_array ::+            forall args . Fullfilled "shape_array(ndarray)" args =>+              ArgsHMap "shape_array(ndarray)" args -> IO [NDArrayHandle]+shape_array args+  = let scalarArgs+          = catMaybes+              [("lhs_begin",) . showValue <$>+                 (args !? #lhs_begin :: Maybe (Maybe Int)),+               ("lhs_end",) . showValue <$>+                 (args !? #lhs_end :: Maybe (Maybe Int)),+               ("rhs_begin",) . showValue <$>+                 (args !? #rhs_begin :: Maybe (Maybe Int)),+               ("rhs_end",) . showValue <$>+                 (args !? #rhs_end :: Maybe (Maybe Int))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "shape_array"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++shape_array_upd ::+                forall args . Fullfilled "shape_array(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "shape_array(ndarray)" args -> IO ()+shape_array_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lhs_begin",) . showValue <$>+                 (args !? #lhs_begin :: Maybe (Maybe Int)),+               ("lhs_end",) . showValue <$>+                 (args !? #lhs_end :: Maybe (Maybe Int)),+               ("rhs_begin",) . showValue <$>+                 (args !? #rhs_begin :: Maybe (Maybe Int)),+               ("rhs_end",) . showValue <$>+                 (args !? #rhs_end :: Maybe (Maybe Int))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "shape_array"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "size_array(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++size_array ::+           forall args . Fullfilled "size_array(ndarray)" args =>+             ArgsHMap "size_array(ndarray)" args -> IO [NDArrayHandle]+size_array args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "size_array"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++size_array_upd ::+               forall args . Fullfilled "size_array(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "size_array(ndarray)" args -> IO ()+size_array_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "size_array"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Cast(ndarray)" =+     '[ '("dtype",+          AttrReq+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("data", AttrOpt NDArrayHandle)]++_Cast ::+      forall args . Fullfilled "_Cast(ndarray)" args =>+        ArgsHMap "_Cast(ndarray)" args -> IO [NDArrayHandle]+_Cast args+  = let scalarArgs+          = catMaybes+              [("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Cast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Cast_upd ::+          forall args . Fullfilled "_Cast(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "_Cast(ndarray)" args -> IO ()+_Cast_upd outputs args+  = let scalarArgs+          = catMaybes+              [("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Cast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_cast(ndarray)" = '[]++_backward_cast ::+               forall args . Fullfilled "_backward_cast(ndarray)" args =>+                 ArgsHMap "_backward_cast(ndarray)" args -> IO [NDArrayHandle]+_backward_cast args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_cast_upd ::+                   forall args . Fullfilled "_backward_cast(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_cast(ndarray)" args -> IO ()+_backward_cast_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "negative(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++negative ::+         forall args . Fullfilled "negative(ndarray)" args =>+           ArgsHMap "negative(ndarray)" args -> IO [NDArrayHandle]+negative args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "negative"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++negative_upd ::+             forall args . Fullfilled "negative(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "negative(ndarray)" args -> IO ()+negative_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "negative"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "reciprocal(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++reciprocal ::+           forall args . Fullfilled "reciprocal(ndarray)" args =>+             ArgsHMap "reciprocal(ndarray)" args -> IO [NDArrayHandle]+reciprocal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reciprocal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++reciprocal_upd ::+               forall args . Fullfilled "reciprocal(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "reciprocal(ndarray)" args -> IO ()+reciprocal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reciprocal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_reciprocal(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_reciprocal ::+                     forall args . Fullfilled "_backward_reciprocal(ndarray)" args =>+                       ArgsHMap "_backward_reciprocal(ndarray)" args -> IO [NDArrayHandle]+_backward_reciprocal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_reciprocal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_reciprocal_upd ::+                         forall args . Fullfilled "_backward_reciprocal(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_reciprocal(ndarray)" args -> IO ()+_backward_reciprocal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_reciprocal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "abs(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++abs ::+    forall args . Fullfilled "abs(ndarray)" args =>+      ArgsHMap "abs(ndarray)" args -> IO [NDArrayHandle]+abs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "abs"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++abs_upd ::+        forall args . Fullfilled "abs(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "abs(ndarray)" args -> IO ()+abs_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "abs"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_abs(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_abs ::+              forall args . Fullfilled "_backward_abs(ndarray)" args =>+                ArgsHMap "_backward_abs(ndarray)" args -> IO [NDArrayHandle]+_backward_abs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_abs"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_abs_upd ::+                  forall args . Fullfilled "_backward_abs(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_abs(ndarray)" args -> IO ()+_backward_abs_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_abs"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "sign(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++sign ::+     forall args . Fullfilled "sign(ndarray)" args =>+       ArgsHMap "sign(ndarray)" args -> IO [NDArrayHandle]+sign args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++sign_upd ::+         forall args . Fullfilled "sign(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "sign(ndarray)" args -> IO ()+sign_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_sign(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_sign ::+               forall args . Fullfilled "_backward_sign(ndarray)" args =>+                 ArgsHMap "_backward_sign(ndarray)" args -> IO [NDArrayHandle]+_backward_sign args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_sign_upd ::+                   forall args . Fullfilled "_backward_sign(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_sign(ndarray)" args -> IO ()+_backward_sign_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "round(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++round ::+      forall args . Fullfilled "round(ndarray)" args =>+        ArgsHMap "round(ndarray)" args -> IO [NDArrayHandle]+round args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "round"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++round_upd ::+          forall args . Fullfilled "round(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "round(ndarray)" args -> IO ()+round_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "round"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "rint(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++rint ::+     forall args . Fullfilled "rint(ndarray)" args =>+       ArgsHMap "rint(ndarray)" args -> IO [NDArrayHandle]+rint args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rint"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++rint_upd ::+         forall args . Fullfilled "rint(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "rint(ndarray)" args -> IO ()+rint_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rint"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "ceil(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++ceil ::+     forall args . Fullfilled "ceil(ndarray)" args =>+       ArgsHMap "ceil(ndarray)" args -> IO [NDArrayHandle]+ceil args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ceil"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++ceil_upd ::+         forall args . Fullfilled "ceil(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "ceil(ndarray)" args -> IO ()+ceil_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ceil"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "floor(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++floor ::+      forall args . Fullfilled "floor(ndarray)" args =>+        ArgsHMap "floor(ndarray)" args -> IO [NDArrayHandle]+floor args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "floor"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++floor_upd ::+          forall args . Fullfilled "floor(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "floor(ndarray)" args -> IO ()+floor_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "floor"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "trunc(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++trunc ::+      forall args . Fullfilled "trunc(ndarray)" args =>+        ArgsHMap "trunc(ndarray)" args -> IO [NDArrayHandle]+trunc args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "trunc"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++trunc_upd ::+          forall args . Fullfilled "trunc(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "trunc(ndarray)" args -> IO ()+trunc_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "trunc"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "fix(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++fix ::+    forall args . Fullfilled "fix(ndarray)" args =>+      ArgsHMap "fix(ndarray)" args -> IO [NDArrayHandle]+fix args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "fix"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++fix_upd ::+        forall args . Fullfilled "fix(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "fix(ndarray)" args -> IO ()+fix_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "fix"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "square(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++square ::+       forall args . Fullfilled "square(ndarray)" args =>+         ArgsHMap "square(ndarray)" args -> IO [NDArrayHandle]+square args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "square"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++square_upd ::+           forall args . Fullfilled "square(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "square(ndarray)" args -> IO ()+square_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "square"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_square(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_square ::+                 forall args . Fullfilled "_backward_square(ndarray)" args =>+                   ArgsHMap "_backward_square(ndarray)" args -> IO [NDArrayHandle]+_backward_square args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_square"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_square_upd ::+                     forall args . Fullfilled "_backward_square(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_backward_square(ndarray)" args -> IO ()+_backward_square_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_square"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "sqrt(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++sqrt ::+     forall args . Fullfilled "sqrt(ndarray)" args =>+       ArgsHMap "sqrt(ndarray)" args -> IO [NDArrayHandle]+sqrt args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sqrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++sqrt_upd ::+         forall args . Fullfilled "sqrt(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "sqrt(ndarray)" args -> IO ()+sqrt_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sqrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_sqrt(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_sqrt ::+               forall args . Fullfilled "_backward_sqrt(ndarray)" args =>+                 ArgsHMap "_backward_sqrt(ndarray)" args -> IO [NDArrayHandle]+_backward_sqrt args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sqrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_sqrt_upd ::+                   forall args . Fullfilled "_backward_sqrt(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_sqrt(ndarray)" args -> IO ()+_backward_sqrt_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sqrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "rsqrt(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++rsqrt ::+      forall args . Fullfilled "rsqrt(ndarray)" args =>+        ArgsHMap "rsqrt(ndarray)" args -> IO [NDArrayHandle]+rsqrt args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rsqrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++rsqrt_upd ::+          forall args . Fullfilled "rsqrt(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "rsqrt(ndarray)" args -> IO ()+rsqrt_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rsqrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_rsqrt(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_rsqrt ::+                forall args . Fullfilled "_backward_rsqrt(ndarray)" args =>+                  ArgsHMap "_backward_rsqrt(ndarray)" args -> IO [NDArrayHandle]+_backward_rsqrt args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rsqrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_rsqrt_upd ::+                    forall args . Fullfilled "_backward_rsqrt(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_rsqrt(ndarray)" args -> IO ()+_backward_rsqrt_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rsqrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "cbrt(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++cbrt ::+     forall args . Fullfilled "cbrt(ndarray)" args =>+       ArgsHMap "cbrt(ndarray)" args -> IO [NDArrayHandle]+cbrt args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cbrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++cbrt_upd ::+         forall args . Fullfilled "cbrt(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "cbrt(ndarray)" args -> IO ()+cbrt_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cbrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_cbrt(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_cbrt ::+               forall args . Fullfilled "_backward_cbrt(ndarray)" args =>+                 ArgsHMap "_backward_cbrt(ndarray)" args -> IO [NDArrayHandle]+_backward_cbrt args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cbrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_cbrt_upd ::+                   forall args . Fullfilled "_backward_cbrt(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_cbrt(ndarray)" args -> IO ()+_backward_cbrt_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cbrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "erf(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++erf ::+    forall args . Fullfilled "erf(ndarray)" args =>+      ArgsHMap "erf(ndarray)" args -> IO [NDArrayHandle]+erf args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "erf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++erf_upd ::+        forall args . Fullfilled "erf(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "erf(ndarray)" args -> IO ()+erf_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "erf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_erf(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_erf ::+              forall args . Fullfilled "_backward_erf(ndarray)" args =>+                ArgsHMap "_backward_erf(ndarray)" args -> IO [NDArrayHandle]+_backward_erf args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_erf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_erf_upd ::+                  forall args . Fullfilled "_backward_erf(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_erf(ndarray)" args -> IO ()+_backward_erf_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_erf"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "erfinv(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++erfinv ::+       forall args . Fullfilled "erfinv(ndarray)" args =>+         ArgsHMap "erfinv(ndarray)" args -> IO [NDArrayHandle]+erfinv args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "erfinv"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++erfinv_upd ::+           forall args . Fullfilled "erfinv(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "erfinv(ndarray)" args -> IO ()+erfinv_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "erfinv"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_erfinv(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_erfinv ::+                 forall args . Fullfilled "_backward_erfinv(ndarray)" args =>+                   ArgsHMap "_backward_erfinv(ndarray)" args -> IO [NDArrayHandle]+_backward_erfinv args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_erfinv"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_erfinv_upd ::+                     forall args . Fullfilled "_backward_erfinv(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_backward_erfinv(ndarray)" args -> IO ()+_backward_erfinv_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_erfinv"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "rcbrt(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++rcbrt ::+      forall args . Fullfilled "rcbrt(ndarray)" args =>+        ArgsHMap "rcbrt(ndarray)" args -> IO [NDArrayHandle]+rcbrt args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rcbrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++rcbrt_upd ::+          forall args . Fullfilled "rcbrt(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "rcbrt(ndarray)" args -> IO ()+rcbrt_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rcbrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_rcbrt(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_rcbrt ::+                forall args . Fullfilled "_backward_rcbrt(ndarray)" args =>+                  ArgsHMap "_backward_rcbrt(ndarray)" args -> IO [NDArrayHandle]+_backward_rcbrt args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rcbrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_rcbrt_upd ::+                    forall args . Fullfilled "_backward_rcbrt(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_rcbrt(ndarray)" args -> IO ()+_backward_rcbrt_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rcbrt"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "exp(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++exp ::+    forall args . Fullfilled "exp(ndarray)" args =>+      ArgsHMap "exp(ndarray)" args -> IO [NDArrayHandle]+exp args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "exp"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++exp_upd ::+        forall args . Fullfilled "exp(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "exp(ndarray)" args -> IO ()+exp_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "exp"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "log(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++log ::+    forall args . Fullfilled "log(ndarray)" args =>+      ArgsHMap "log(ndarray)" args -> IO [NDArrayHandle]+log args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++log_upd ::+        forall args . Fullfilled "log(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "log(ndarray)" args -> IO ()+log_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "log10(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++log10 ::+      forall args . Fullfilled "log10(ndarray)" args =>+        ArgsHMap "log10(ndarray)" args -> IO [NDArrayHandle]+log10 args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log10"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++log10_upd ::+          forall args . Fullfilled "log10(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "log10(ndarray)" args -> IO ()+log10_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log10"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "log2(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++log2 ::+     forall args . Fullfilled "log2(ndarray)" args =>+       ArgsHMap "log2(ndarray)" args -> IO [NDArrayHandle]+log2 args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log2"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++log2_upd ::+         forall args . Fullfilled "log2(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "log2(ndarray)" args -> IO ()+log2_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log2"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_log(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_log ::+              forall args . Fullfilled "_backward_log(ndarray)" args =>+                ArgsHMap "_backward_log(ndarray)" args -> IO [NDArrayHandle]+_backward_log args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_log_upd ::+                  forall args . Fullfilled "_backward_log(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_log(ndarray)" args -> IO ()+_backward_log_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_log10(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_log10 ::+                forall args . Fullfilled "_backward_log10(ndarray)" args =>+                  ArgsHMap "_backward_log10(ndarray)" args -> IO [NDArrayHandle]+_backward_log10 args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log10"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_log10_upd ::+                    forall args . Fullfilled "_backward_log10(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_log10(ndarray)" args -> IO ()+_backward_log10_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log10"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_log2(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_log2 ::+               forall args . Fullfilled "_backward_log2(ndarray)" args =>+                 ArgsHMap "_backward_log2(ndarray)" args -> IO [NDArrayHandle]+_backward_log2 args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log2"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_log2_upd ::+                   forall args . Fullfilled "_backward_log2(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_log2(ndarray)" args -> IO ()+_backward_log2_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log2"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "log1p(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++log1p ::+      forall args . Fullfilled "log1p(ndarray)" args =>+        ArgsHMap "log1p(ndarray)" args -> IO [NDArrayHandle]+log1p args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log1p"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++log1p_upd ::+          forall args . Fullfilled "log1p(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "log1p(ndarray)" args -> IO ()+log1p_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log1p"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_log1p(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_log1p ::+                forall args . Fullfilled "_backward_log1p(ndarray)" args =>+                  ArgsHMap "_backward_log1p(ndarray)" args -> IO [NDArrayHandle]+_backward_log1p args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log1p"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_log1p_upd ::+                    forall args . Fullfilled "_backward_log1p(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_log1p(ndarray)" args -> IO ()+_backward_log1p_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log1p"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "expm1(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++expm1 ::+      forall args . Fullfilled "expm1(ndarray)" args =>+        ArgsHMap "expm1(ndarray)" args -> IO [NDArrayHandle]+expm1 args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "expm1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++expm1_upd ::+          forall args . Fullfilled "expm1(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "expm1(ndarray)" args -> IO ()+expm1_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "expm1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_expm1(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_expm1 ::+                forall args . Fullfilled "_backward_expm1(ndarray)" args =>+                  ArgsHMap "_backward_expm1(ndarray)" args -> IO [NDArrayHandle]+_backward_expm1 args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_expm1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_expm1_upd ::+                    forall args . Fullfilled "_backward_expm1(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_expm1(ndarray)" args -> IO ()+_backward_expm1_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_expm1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "gamma(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++gamma ::+      forall args . Fullfilled "gamma(ndarray)" args =>+        ArgsHMap "gamma(ndarray)" args -> IO [NDArrayHandle]+gamma args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gamma"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++gamma_upd ::+          forall args . Fullfilled "gamma(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "gamma(ndarray)" args -> IO ()+gamma_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gamma"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_gamma(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_gamma ::+                forall args . Fullfilled "_backward_gamma(ndarray)" args =>+                  ArgsHMap "_backward_gamma(ndarray)" args -> IO [NDArrayHandle]+_backward_gamma args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_gamma"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_gamma_upd ::+                    forall args . Fullfilled "_backward_gamma(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_gamma(ndarray)" args -> IO ()+_backward_gamma_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_gamma"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "gammaln(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++gammaln ::+        forall args . Fullfilled "gammaln(ndarray)" args =>+          ArgsHMap "gammaln(ndarray)" args -> IO [NDArrayHandle]+gammaln args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gammaln"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++gammaln_upd ::+            forall args . Fullfilled "gammaln(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "gammaln(ndarray)" args -> IO ()+gammaln_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gammaln"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_gammaln(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_gammaln ::+                  forall args . Fullfilled "_backward_gammaln(ndarray)" args =>+                    ArgsHMap "_backward_gammaln(ndarray)" args -> IO [NDArrayHandle]+_backward_gammaln args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_gammaln"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_gammaln_upd ::+                      forall args . Fullfilled "_backward_gammaln(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_gammaln(ndarray)" args -> IO ()+_backward_gammaln_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_gammaln"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "logical_not(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++logical_not ::+            forall args . Fullfilled "logical_not(ndarray)" args =>+              ArgsHMap "logical_not(ndarray)" args -> IO [NDArrayHandle]+logical_not args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "logical_not"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++logical_not_upd ::+                forall args . Fullfilled "logical_not(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "logical_not(ndarray)" args -> IO ()+logical_not_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "logical_not"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "amp_cast(ndarray)" =+     '[ '("dtype",+          AttrReq+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("data", AttrOpt NDArrayHandle)]++amp_cast ::+         forall args . Fullfilled "amp_cast(ndarray)" args =>+           ArgsHMap "amp_cast(ndarray)" args -> IO [NDArrayHandle]+amp_cast args+  = let scalarArgs+          = catMaybes+              [("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "amp_cast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++amp_cast_upd ::+             forall args . Fullfilled "amp_cast(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "amp_cast(ndarray)" args -> IO ()+amp_cast_upd outputs args+  = let scalarArgs+          = catMaybes+              [("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "amp_cast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_amp_cast(ndarray)" = '[]++_backward_amp_cast ::+                   forall args . Fullfilled "_backward_amp_cast(ndarray)" args =>+                     ArgsHMap "_backward_amp_cast(ndarray)" args -> IO [NDArrayHandle]+_backward_amp_cast args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_amp_cast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_amp_cast_upd ::+                       forall args . Fullfilled "_backward_amp_cast(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_backward_amp_cast(ndarray)" args -> IO ()+_backward_amp_cast_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_amp_cast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "amp_multicast(ndarray)" =+     '[ '("num_outputs", AttrReq Int),+        '("data", AttrOpt [NDArrayHandle])]++amp_multicast ::+              forall args . Fullfilled "amp_multicast(ndarray)" args =>+                ArgsHMap "amp_multicast(ndarray)" args -> IO [NDArrayHandle]+amp_multicast args+  = let scalarArgs+          = catMaybes+              [("num_outputs",) . showValue <$>+                 (args !? #num_outputs :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "amp_multicast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++amp_multicast_upd ::+                  forall args . Fullfilled "amp_multicast(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "amp_multicast(ndarray)" args -> IO ()+amp_multicast_upd outputs args+  = let scalarArgs+          = catMaybes+              [("num_outputs",) . showValue <$>+                 (args !? #num_outputs :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "amp_multicast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_amp_multicast(ndarray)" =+     '[ '("num_outputs", AttrReq Int),+        '("grad", AttrOpt [NDArrayHandle])]++_backward_amp_multicast ::+                        forall args . Fullfilled "_backward_amp_multicast(ndarray)" args =>+                          ArgsHMap "_backward_amp_multicast(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_amp_multicast args+  = let scalarArgs+          = catMaybes+              [("num_outputs",) . showValue <$>+                 (args !? #num_outputs :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #grad :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "_backward_amp_multicast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_amp_multicast_upd ::+                            forall args . Fullfilled "_backward_amp_multicast(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_amp_multicast(ndarray)" args -> IO ()+_backward_amp_multicast_upd outputs args+  = let scalarArgs+          = catMaybes+              [("num_outputs",) . showValue <$>+                 (args !? #num_outputs :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #grad :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "_backward_amp_multicast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "elemwise_add(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++elemwise_add ::+             forall args . Fullfilled "elemwise_add(ndarray)" args =>+               ArgsHMap "elemwise_add(ndarray)" args -> IO [NDArrayHandle]+elemwise_add args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++elemwise_add_upd ::+                 forall args . Fullfilled "elemwise_add(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "elemwise_add(ndarray)" args -> IO ()+elemwise_add_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_grad_add(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_grad_add ::+          forall args . Fullfilled "_grad_add(ndarray)" args =>+            ArgsHMap "_grad_add(ndarray)" args -> IO [NDArrayHandle]+_grad_add args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_grad_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_grad_add_upd ::+              forall args . Fullfilled "_grad_add(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "_grad_add(ndarray)" args -> IO ()+_grad_add_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_grad_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_add(ndarray)" = '[]++_backward_add ::+              forall args . Fullfilled "_backward_add(ndarray)" args =>+                ArgsHMap "_backward_add(ndarray)" args -> IO [NDArrayHandle]+_backward_add args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_add_upd ::+                  forall args . Fullfilled "_backward_add(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_add(ndarray)" args -> IO ()+_backward_add_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "elemwise_sub(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++elemwise_sub ::+             forall args . Fullfilled "elemwise_sub(ndarray)" args =>+               ArgsHMap "elemwise_sub(ndarray)" args -> IO [NDArrayHandle]+elemwise_sub args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_sub"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++elemwise_sub_upd ::+                 forall args . Fullfilled "elemwise_sub(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "elemwise_sub(ndarray)" args -> IO ()+elemwise_sub_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_sub"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_sub(ndarray)" = '[]++_backward_sub ::+              forall args . Fullfilled "_backward_sub(ndarray)" args =>+                ArgsHMap "_backward_sub(ndarray)" args -> IO [NDArrayHandle]+_backward_sub args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sub"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_sub_upd ::+                  forall args . Fullfilled "_backward_sub(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_sub(ndarray)" args -> IO ()+_backward_sub_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sub"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "elemwise_mul(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++elemwise_mul ::+             forall args . Fullfilled "elemwise_mul(ndarray)" args =>+               ArgsHMap "elemwise_mul(ndarray)" args -> IO [NDArrayHandle]+elemwise_mul args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_mul"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++elemwise_mul_upd ::+                 forall args . Fullfilled "elemwise_mul(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "elemwise_mul(ndarray)" args -> IO ()+elemwise_mul_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_mul"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_mul(ndarray)" = '[]++_backward_mul ::+              forall args . Fullfilled "_backward_mul(ndarray)" args =>+                ArgsHMap "_backward_mul(ndarray)" args -> IO [NDArrayHandle]+_backward_mul args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mul"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_mul_upd ::+                  forall args . Fullfilled "_backward_mul(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_mul(ndarray)" args -> IO ()+_backward_mul_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mul"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "elemwise_div(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++elemwise_div ::+             forall args . Fullfilled "elemwise_div(ndarray)" args =>+               ArgsHMap "elemwise_div(ndarray)" args -> IO [NDArrayHandle]+elemwise_div args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++elemwise_div_upd ::+                 forall args . Fullfilled "elemwise_div(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "elemwise_div(ndarray)" args -> IO ()+elemwise_div_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_div(ndarray)" = '[]++_backward_div ::+              forall args . Fullfilled "_backward_div(ndarray)" args =>+                ArgsHMap "_backward_div(ndarray)" args -> IO [NDArrayHandle]+_backward_div args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_div_upd ::+                  forall args . Fullfilled "_backward_div(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_div(ndarray)" args -> IO ()+_backward_div_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_mod(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_mod ::+     forall args . Fullfilled "_mod(ndarray)" args =>+       ArgsHMap "_mod(ndarray)" args -> IO [NDArrayHandle]+_mod args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_mod_upd ::+         forall args . Fullfilled "_mod(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "_mod(ndarray)" args -> IO ()+_mod_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_mod(ndarray)" = '[]++_backward_mod ::+              forall args . Fullfilled "_backward_mod(ndarray)" args =>+                ArgsHMap "_backward_mod(ndarray)" args -> IO [NDArrayHandle]+_backward_mod args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_mod_upd ::+                  forall args . Fullfilled "_backward_mod(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_mod(ndarray)" args -> IO ()+_backward_mod_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_scatter_elemwise_div(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_scatter_elemwise_div ::+                      forall args . Fullfilled "_scatter_elemwise_div(ndarray)" args =>+                        ArgsHMap "_scatter_elemwise_div(ndarray)" args ->+                          IO [NDArrayHandle]+_scatter_elemwise_div args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_elemwise_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_scatter_elemwise_div_upd ::+                          forall args . Fullfilled "_scatter_elemwise_div(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_scatter_elemwise_div(ndarray)" args -> IO ()+_scatter_elemwise_div_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_elemwise_div"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_scatter_plus_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_scatter_plus_scalar ::+                     forall args . Fullfilled "_scatter_plus_scalar(ndarray)" args =>+                       ArgsHMap "_scatter_plus_scalar(ndarray)" args -> IO [NDArrayHandle]+_scatter_plus_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_plus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_scatter_plus_scalar_upd ::+                         forall args . Fullfilled "_scatter_plus_scalar(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_scatter_plus_scalar(ndarray)" args -> IO ()+_scatter_plus_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_plus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_scatter_minus_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_scatter_minus_scalar ::+                      forall args . Fullfilled "_scatter_minus_scalar(ndarray)" args =>+                        ArgsHMap "_scatter_minus_scalar(ndarray)" args ->+                          IO [NDArrayHandle]+_scatter_minus_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_minus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_scatter_minus_scalar_upd ::+                          forall args . Fullfilled "_scatter_minus_scalar(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_scatter_minus_scalar(ndarray)" args -> IO ()+_scatter_minus_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_minus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Embedding(ndarray)" =+     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("sparse_grad", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),+        '("weight", AttrOpt NDArrayHandle)]++_Embedding ::+           forall args . Fullfilled "_Embedding(ndarray)" args =>+             ArgsHMap "_Embedding(ndarray)" args -> IO [NDArrayHandle]+_Embedding args+  = let scalarArgs+          = catMaybes+              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"])),+               ("sparse_grad",) . showValue <$>+                 (args !? #sparse_grad :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Embedding"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Embedding_upd ::+               forall args . Fullfilled "_Embedding(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "_Embedding(ndarray)" args -> IO ()+_Embedding_upd outputs args+  = let scalarArgs+          = catMaybes+              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"])),+               ("sparse_grad",) . showValue <$>+                 (args !? #sparse_grad :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Embedding"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_SparseEmbedding(ndarray)" =+     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("sparse_grad", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),+        '("weight", AttrOpt NDArrayHandle)]++_contrib_SparseEmbedding ::+                         forall args .+                           Fullfilled "_contrib_SparseEmbedding(ndarray)" args =>+                           ArgsHMap "_contrib_SparseEmbedding(ndarray)" args ->+                             IO [NDArrayHandle]+_contrib_SparseEmbedding args+  = let scalarArgs+          = catMaybes+              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"])),+               ("sparse_grad",) . showValue <$>+                 (args !? #sparse_grad :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_SparseEmbedding"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_SparseEmbedding_upd ::+                             forall args .+                               Fullfilled "_contrib_SparseEmbedding(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_contrib_SparseEmbedding(ndarray)" args -> IO ()+_contrib_SparseEmbedding_upd outputs args+  = let scalarArgs+          = catMaybes+              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"])),+               ("sparse_grad",) . showValue <$>+                 (args !? #sparse_grad :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_SparseEmbedding"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Embedding(ndarray)" = '[]++_backward_Embedding ::+                    forall args . Fullfilled "_backward_Embedding(ndarray)" args =>+                      ArgsHMap "_backward_Embedding(ndarray)" args -> IO [NDArrayHandle]+_backward_Embedding args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Embedding"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Embedding_upd ::+                        forall args . Fullfilled "_backward_Embedding(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_backward_Embedding(ndarray)" args -> IO ()+_backward_Embedding_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Embedding"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SparseEmbedding(ndarray)" =+     '[]++_backward_SparseEmbedding ::+                          forall args .+                            Fullfilled "_backward_SparseEmbedding(ndarray)" args =>+                            ArgsHMap "_backward_SparseEmbedding(ndarray)" args ->+                              IO [NDArrayHandle]+_backward_SparseEmbedding args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SparseEmbedding"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SparseEmbedding_upd ::+                              forall args .+                                Fullfilled "_backward_SparseEmbedding(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_backward_SparseEmbedding(ndarray)" args -> IO ()+_backward_SparseEmbedding_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SparseEmbedding"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "take(ndarray)" =+     '[ '("axis", AttrOpt Int),+        '("mode", AttrOpt (EnumType '["clip", "raise", "wrap"])),+        '("a", AttrOpt NDArrayHandle), '("indices", AttrOpt NDArrayHandle)]++take ::+     forall args . Fullfilled "take(ndarray)" args =>+       ArgsHMap "take(ndarray)" args -> IO [NDArrayHandle]+take args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))]+        tensorArgs+          = catMaybes+              [("a",) <$> (args !? #a :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "take"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++take_upd ::+         forall args . Fullfilled "take(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "take(ndarray)" args -> IO ()+take_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))]+        tensorArgs+          = catMaybes+              [("a",) <$> (args !? #a :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "take"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_take(ndarray)" = '[]++_backward_take ::+               forall args . Fullfilled "_backward_take(ndarray)" args =>+                 ArgsHMap "_backward_take(ndarray)" args -> IO [NDArrayHandle]+_backward_take args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_take"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_take_upd ::+                   forall args . Fullfilled "_backward_take(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_take(ndarray)" args -> IO ()+_backward_take_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_take"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "batch_take(ndarray)" =+     '[ '("a", AttrOpt NDArrayHandle),+        '("indices", AttrOpt NDArrayHandle)]++batch_take ::+           forall args . Fullfilled "batch_take(ndarray)" args =>+             ArgsHMap "batch_take(ndarray)" args -> IO [NDArrayHandle]+batch_take args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("a",) <$> (args !? #a :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "batch_take"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++batch_take_upd ::+               forall args . Fullfilled "batch_take(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "batch_take(ndarray)" args -> IO ()+batch_take_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("a",) <$> (args !? #a :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "batch_take"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "one_hot(ndarray)" =+     '[ '("depth", AttrReq Int), '("on_value", AttrOpt Double),+        '("off_value", AttrOpt Double),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("indices", AttrOpt NDArrayHandle)]++one_hot ::+        forall args . Fullfilled "one_hot(ndarray)" args =>+          ArgsHMap "one_hot(ndarray)" args -> IO [NDArrayHandle]+one_hot args+  = let scalarArgs+          = catMaybes+              [("depth",) . showValue <$> (args !? #depth :: Maybe Int),+               ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double),+               ("off_value",) . showValue <$>+                 (args !? #off_value :: Maybe Double),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs+          = catMaybes+              [("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "one_hot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++one_hot_upd ::+            forall args . Fullfilled "one_hot(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "one_hot(ndarray)" args -> IO ()+one_hot_upd outputs args+  = let scalarArgs+          = catMaybes+              [("depth",) . showValue <$> (args !? #depth :: Maybe Int),+               ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double),+               ("off_value",) . showValue <$>+                 (args !? #off_value :: Maybe Double),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        tensorArgs+          = catMaybes+              [("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "one_hot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "gather_nd(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle),+        '("indices", AttrOpt NDArrayHandle)]++gather_nd ::+          forall args . Fullfilled "gather_nd(ndarray)" args =>+            ArgsHMap "gather_nd(ndarray)" args -> IO [NDArrayHandle]+gather_nd args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gather_nd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++gather_nd_upd ::+              forall args . Fullfilled "gather_nd(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "gather_nd(ndarray)" args -> IO ()+gather_nd_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gather_nd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "scatter_nd(ndarray)" =+     '[ '("shape", AttrReq [Int]), '("data", AttrOpt NDArrayHandle),+        '("indices", AttrOpt NDArrayHandle)]++scatter_nd ::+           forall args . Fullfilled "scatter_nd(ndarray)" args =>+             ArgsHMap "scatter_nd(ndarray)" args -> IO [NDArrayHandle]+scatter_nd args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "scatter_nd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++scatter_nd_upd ::+               forall args . Fullfilled "scatter_nd(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "scatter_nd(ndarray)" args -> IO ()+scatter_nd_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "scatter_nd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_gather_nd(ndarray)" =+     '[ '("shape", AttrReq [Int]), '("data", AttrOpt NDArrayHandle),+        '("indices", AttrOpt NDArrayHandle)]++_backward_gather_nd ::+                    forall args . Fullfilled "_backward_gather_nd(ndarray)" args =>+                      ArgsHMap "_backward_gather_nd(ndarray)" args -> IO [NDArrayHandle]+_backward_gather_nd args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_gather_nd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_gather_nd_upd ::+                        forall args . Fullfilled "_backward_gather_nd(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_backward_gather_nd(ndarray)" args -> IO ()+_backward_gather_nd_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_gather_nd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_scatter_set_nd(ndarray)" =+     '[ '("shape", AttrReq [Int]), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle),+        '("indices", AttrOpt NDArrayHandle)]++_scatter_set_nd ::+                forall args . Fullfilled "_scatter_set_nd(ndarray)" args =>+                  ArgsHMap "_scatter_set_nd(ndarray)" args -> IO [NDArrayHandle]+_scatter_set_nd args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_set_nd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_scatter_set_nd_upd ::+                    forall args . Fullfilled "_scatter_set_nd(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_scatter_set_nd(ndarray)" args -> IO ()+_scatter_set_nd_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_set_nd"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_equal(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_equal ::+                forall args . Fullfilled "broadcast_equal(ndarray)" args =>+                  ArgsHMap "broadcast_equal(ndarray)" args -> IO [NDArrayHandle]+broadcast_equal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_equal_upd ::+                    forall args . Fullfilled "broadcast_equal(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "broadcast_equal(ndarray)" args -> IO ()+broadcast_equal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_not_equal(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_not_equal ::+                    forall args . Fullfilled "broadcast_not_equal(ndarray)" args =>+                      ArgsHMap "broadcast_not_equal(ndarray)" args -> IO [NDArrayHandle]+broadcast_not_equal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_not_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_not_equal_upd ::+                        forall args . Fullfilled "broadcast_not_equal(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "broadcast_not_equal(ndarray)" args -> IO ()+broadcast_not_equal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_not_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_greater(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_greater ::+                  forall args . Fullfilled "broadcast_greater(ndarray)" args =>+                    ArgsHMap "broadcast_greater(ndarray)" args -> IO [NDArrayHandle]+broadcast_greater args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_greater"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_greater_upd ::+                      forall args . Fullfilled "broadcast_greater(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "broadcast_greater(ndarray)" args -> IO ()+broadcast_greater_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_greater"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_greater_equal(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_greater_equal ::+                        forall args . Fullfilled "broadcast_greater_equal(ndarray)" args =>+                          ArgsHMap "broadcast_greater_equal(ndarray)" args ->+                            IO [NDArrayHandle]+broadcast_greater_equal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_greater_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_greater_equal_upd ::+                            forall args . Fullfilled "broadcast_greater_equal(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "broadcast_greater_equal(ndarray)" args -> IO ()+broadcast_greater_equal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_greater_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_lesser(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_lesser ::+                 forall args . Fullfilled "broadcast_lesser(ndarray)" args =>+                   ArgsHMap "broadcast_lesser(ndarray)" args -> IO [NDArrayHandle]+broadcast_lesser args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_lesser"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_lesser_upd ::+                     forall args . Fullfilled "broadcast_lesser(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "broadcast_lesser(ndarray)" args -> IO ()+broadcast_lesser_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_lesser"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_lesser_equal(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_lesser_equal ::+                       forall args . Fullfilled "broadcast_lesser_equal(ndarray)" args =>+                         ArgsHMap "broadcast_lesser_equal(ndarray)" args ->+                           IO [NDArrayHandle]+broadcast_lesser_equal args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_lesser_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_lesser_equal_upd ::+                           forall args . Fullfilled "broadcast_lesser_equal(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "broadcast_lesser_equal(ndarray)" args -> IO ()+broadcast_lesser_equal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_lesser_equal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_logical_and(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_logical_and ::+                      forall args . Fullfilled "broadcast_logical_and(ndarray)" args =>+                        ArgsHMap "broadcast_logical_and(ndarray)" args ->+                          IO [NDArrayHandle]+broadcast_logical_and args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_logical_and"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_logical_and_upd ::+                          forall args . Fullfilled "broadcast_logical_and(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "broadcast_logical_and(ndarray)" args -> IO ()+broadcast_logical_and_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_logical_and"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_logical_or(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_logical_or ::+                     forall args . Fullfilled "broadcast_logical_or(ndarray)" args =>+                       ArgsHMap "broadcast_logical_or(ndarray)" args -> IO [NDArrayHandle]+broadcast_logical_or args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_logical_or"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_logical_or_upd ::+                         forall args . Fullfilled "broadcast_logical_or(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "broadcast_logical_or(ndarray)" args -> IO ()+broadcast_logical_or_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_logical_or"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_logical_xor(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++broadcast_logical_xor ::+                      forall args . Fullfilled "broadcast_logical_xor(ndarray)" args =>+                        ArgsHMap "broadcast_logical_xor(ndarray)" args ->+                          IO [NDArrayHandle]+broadcast_logical_xor args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_logical_xor"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_logical_xor_upd ::+                          forall args . Fullfilled "broadcast_logical_xor(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "broadcast_logical_xor(ndarray)" args -> IO ()+broadcast_logical_xor_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_logical_xor"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_plus_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_plus_scalar ::+             forall args . Fullfilled "_plus_scalar(ndarray)" args =>+               ArgsHMap "_plus_scalar(ndarray)" args -> IO [NDArrayHandle]+_plus_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_plus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_plus_scalar_upd ::+                 forall args . Fullfilled "_plus_scalar(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_plus_scalar(ndarray)" args -> IO ()+_plus_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_plus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_minus_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_minus_scalar ::+              forall args . Fullfilled "_minus_scalar(ndarray)" args =>+                ArgsHMap "_minus_scalar(ndarray)" args -> IO [NDArrayHandle]+_minus_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_minus_scalar_upd ::+                  forall args . Fullfilled "_minus_scalar(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_minus_scalar(ndarray)" args -> IO ()+_minus_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_rminus_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_rminus_scalar ::+               forall args . Fullfilled "_rminus_scalar(ndarray)" args =>+                 ArgsHMap "_rminus_scalar(ndarray)" args -> IO [NDArrayHandle]+_rminus_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rminus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_rminus_scalar_upd ::+                   forall args . Fullfilled "_rminus_scalar(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_rminus_scalar(ndarray)" args -> IO ()+_rminus_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rminus_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_mul_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_mul_scalar ::+            forall args . Fullfilled "_mul_scalar(ndarray)" args =>+              ArgsHMap "_mul_scalar(ndarray)" args -> IO [NDArrayHandle]+_mul_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mul_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_mul_scalar_upd ::+                forall args . Fullfilled "_mul_scalar(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_mul_scalar(ndarray)" args -> IO ()+_mul_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mul_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_mul_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_backward_mul_scalar ::+                     forall args . Fullfilled "_backward_mul_scalar(ndarray)" args =>+                       ArgsHMap "_backward_mul_scalar(ndarray)" args -> IO [NDArrayHandle]+_backward_mul_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mul_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_mul_scalar_upd ::+                         forall args . Fullfilled "_backward_mul_scalar(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_mul_scalar(ndarray)" args -> IO ()+_backward_mul_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mul_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_div_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_div_scalar ::+            forall args . Fullfilled "_div_scalar(ndarray)" args =>+              ArgsHMap "_div_scalar(ndarray)" args -> IO [NDArrayHandle]+_div_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_div_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_div_scalar_upd ::+                forall args . Fullfilled "_div_scalar(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_div_scalar(ndarray)" args -> IO ()+_div_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_div_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_div_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_backward_div_scalar ::+                     forall args . Fullfilled "_backward_div_scalar(ndarray)" args =>+                       ArgsHMap "_backward_div_scalar(ndarray)" args -> IO [NDArrayHandle]+_backward_div_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_div_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_div_scalar_upd ::+                         forall args . Fullfilled "_backward_div_scalar(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_div_scalar(ndarray)" args -> IO ()+_backward_div_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_div_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_rdiv_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_rdiv_scalar ::+             forall args . Fullfilled "_rdiv_scalar(ndarray)" args =>+               ArgsHMap "_rdiv_scalar(ndarray)" args -> IO [NDArrayHandle]+_rdiv_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rdiv_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_rdiv_scalar_upd ::+                 forall args . Fullfilled "_rdiv_scalar(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_rdiv_scalar(ndarray)" args -> IO ()+_rdiv_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rdiv_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_rdiv_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_rdiv_scalar ::+                      forall args . Fullfilled "_backward_rdiv_scalar(ndarray)" args =>+                        ArgsHMap "_backward_rdiv_scalar(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_rdiv_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rdiv_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_rdiv_scalar_upd ::+                          forall args . Fullfilled "_backward_rdiv_scalar(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_rdiv_scalar(ndarray)" args -> IO ()+_backward_rdiv_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rdiv_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_mod_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_mod_scalar ::+            forall args . Fullfilled "_mod_scalar(ndarray)" args =>+              ArgsHMap "_mod_scalar(ndarray)" args -> IO [NDArrayHandle]+_mod_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mod_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_mod_scalar_upd ::+                forall args . Fullfilled "_mod_scalar(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_mod_scalar(ndarray)" args -> IO ()+_mod_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mod_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_mod_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_mod_scalar ::+                     forall args . Fullfilled "_backward_mod_scalar(ndarray)" args =>+                       ArgsHMap "_backward_mod_scalar(ndarray)" args -> IO [NDArrayHandle]+_backward_mod_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mod_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_mod_scalar_upd ::+                         forall args . Fullfilled "_backward_mod_scalar(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_mod_scalar(ndarray)" args -> IO ()+_backward_mod_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mod_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_rmod_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_rmod_scalar ::+             forall args . Fullfilled "_rmod_scalar(ndarray)" args =>+               ArgsHMap "_rmod_scalar(ndarray)" args -> IO [NDArrayHandle]+_rmod_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rmod_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_rmod_scalar_upd ::+                 forall args . Fullfilled "_rmod_scalar(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_rmod_scalar(ndarray)" args -> IO ()+_rmod_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rmod_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_rmod_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_rmod_scalar ::+                      forall args . Fullfilled "_backward_rmod_scalar(ndarray)" args =>+                        ArgsHMap "_backward_rmod_scalar(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_rmod_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rmod_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_rmod_scalar_upd ::+                          forall args . Fullfilled "_backward_rmod_scalar(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_rmod_scalar(ndarray)" args -> IO ()+_backward_rmod_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rmod_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_ravel_multi_index(ndarray)" =+     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]++_ravel_multi_index ::+                   forall args . Fullfilled "_ravel_multi_index(ndarray)" args =>+                     ArgsHMap "_ravel_multi_index(ndarray)" args -> IO [NDArrayHandle]+_ravel_multi_index args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_ravel_multi_index"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_ravel_multi_index_upd ::+                       forall args . Fullfilled "_ravel_multi_index(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_ravel_multi_index(ndarray)" args -> IO ()+_ravel_multi_index_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_ravel_multi_index"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_unravel_index(ndarray)" =+     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]++_unravel_index ::+               forall args . Fullfilled "_unravel_index(ndarray)" args =>+                 ArgsHMap "_unravel_index(ndarray)" args -> IO [NDArrayHandle]+_unravel_index args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_unravel_index"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_unravel_index_upd ::+                   forall args . Fullfilled "_unravel_index(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_unravel_index(ndarray)" args -> IO ()+_unravel_index_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_unravel_index"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "sum(ndarray)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++sum ::+    forall args . Fullfilled "sum(ndarray)" args =>+      ArgsHMap "sum(ndarray)" args -> IO [NDArrayHandle]+sum args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++sum_upd ::+        forall args . Fullfilled "sum(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "sum(ndarray)" args -> IO ()+sum_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_sum(ndarray)" = '[]++_backward_sum ::+              forall args . Fullfilled "_backward_sum(ndarray)" args =>+                ArgsHMap "_backward_sum(ndarray)" args -> IO [NDArrayHandle]+_backward_sum args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_sum_upd ::+                  forall args . Fullfilled "_backward_sum(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_sum(ndarray)" args -> IO ()+_backward_sum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "mean(ndarray)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++mean ::+     forall args . Fullfilled "mean(ndarray)" args =>+       ArgsHMap "mean(ndarray)" args -> IO [NDArrayHandle]+mean args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mean"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++mean_upd ::+         forall args . Fullfilled "mean(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "mean(ndarray)" args -> IO ()+mean_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mean"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_mean(ndarray)" = '[]++_backward_mean ::+               forall args . Fullfilled "_backward_mean(ndarray)" args =>+                 ArgsHMap "_backward_mean(ndarray)" args -> IO [NDArrayHandle]+_backward_mean args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mean"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_mean_upd ::+                   forall args . Fullfilled "_backward_mean(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_mean(ndarray)" args -> IO ()+_backward_mean_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mean"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "prod(ndarray)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++prod ::+     forall args . Fullfilled "prod(ndarray)" args =>+       ArgsHMap "prod(ndarray)" args -> IO [NDArrayHandle]+prod args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "prod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++prod_upd ::+         forall args . Fullfilled "prod(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "prod(ndarray)" args -> IO ()+prod_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "prod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_prod(ndarray)" = '[]++_backward_prod ::+               forall args . Fullfilled "_backward_prod(ndarray)" args =>+                 ArgsHMap "_backward_prod(ndarray)" args -> IO [NDArrayHandle]+_backward_prod args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_prod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_prod_upd ::+                   forall args . Fullfilled "_backward_prod(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_prod(ndarray)" args -> IO ()+_backward_prod_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_prod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "nansum(ndarray)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++nansum ::+       forall args . Fullfilled "nansum(ndarray)" args =>+         ArgsHMap "nansum(ndarray)" args -> IO [NDArrayHandle]+nansum args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "nansum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++nansum_upd ::+           forall args . Fullfilled "nansum(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "nansum(ndarray)" args -> IO ()+nansum_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "nansum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_nansum(ndarray)" = '[]++_backward_nansum ::+                 forall args . Fullfilled "_backward_nansum(ndarray)" args =>+                   ArgsHMap "_backward_nansum(ndarray)" args -> IO [NDArrayHandle]+_backward_nansum args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_nansum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_nansum_upd ::+                     forall args . Fullfilled "_backward_nansum(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_backward_nansum(ndarray)" args -> IO ()+_backward_nansum_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_nansum"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "nanprod(ndarray)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++nanprod ::+        forall args . Fullfilled "nanprod(ndarray)" args =>+          ArgsHMap "nanprod(ndarray)" args -> IO [NDArrayHandle]+nanprod args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "nanprod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++nanprod_upd ::+            forall args . Fullfilled "nanprod(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "nanprod(ndarray)" args -> IO ()+nanprod_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "nanprod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_nanprod(ndarray)" = '[]++_backward_nanprod ::+                  forall args . Fullfilled "_backward_nanprod(ndarray)" args =>+                    ArgsHMap "_backward_nanprod(ndarray)" args -> IO [NDArrayHandle]+_backward_nanprod args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_nanprod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_nanprod_upd ::+                      forall args . Fullfilled "_backward_nanprod(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_nanprod(ndarray)" args -> IO ()+_backward_nanprod_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_nanprod"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "max(ndarray)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++max ::+    forall args . Fullfilled "max(ndarray)" args =>+      ArgsHMap "max(ndarray)" args -> IO [NDArrayHandle]+max args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "max"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++max_upd ::+        forall args . Fullfilled "max(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "max(ndarray)" args -> IO ()+max_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "max"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_max(ndarray)" = '[]++_backward_max ::+              forall args . Fullfilled "_backward_max(ndarray)" args =>+                ArgsHMap "_backward_max(ndarray)" args -> IO [NDArrayHandle]+_backward_max args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_max"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_max_upd ::+                  forall args . Fullfilled "_backward_max(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_max(ndarray)" args -> IO ()+_backward_max_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_max"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "min(ndarray)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++min ::+    forall args . Fullfilled "min(ndarray)" args =>+      ArgsHMap "min(ndarray)" args -> IO [NDArrayHandle]+min args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "min"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++min_upd ::+        forall args . Fullfilled "min(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "min(ndarray)" args -> IO ()+min_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "min"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_min(ndarray)" = '[]++_backward_min ::+              forall args . Fullfilled "_backward_min(ndarray)" args =>+                ArgsHMap "_backward_min(ndarray)" args -> IO [NDArrayHandle]+_backward_min args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_min"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_min_upd ::+                  forall args . Fullfilled "_backward_min(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_min(ndarray)" args -> IO ()+_backward_min_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_min"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_axis(ndarray)" =+     '[ '("axis", AttrOpt [Int]), '("size", AttrOpt [Int]),+        '("data", AttrOpt NDArrayHandle)]++broadcast_axis ::+               forall args . Fullfilled "broadcast_axis(ndarray)" args =>+                 ArgsHMap "broadcast_axis(ndarray)" args -> IO [NDArrayHandle]+broadcast_axis args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),+               ("size",) . showValue <$> (args !? #size :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_axis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_axis_upd ::+                   forall args . Fullfilled "broadcast_axis(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "broadcast_axis(ndarray)" args -> IO ()+broadcast_axis_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),+               ("size",) . showValue <$> (args !? #size :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_axis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_to(ndarray)" =+     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]++broadcast_to ::+             forall args . Fullfilled "broadcast_to(ndarray)" args =>+               ArgsHMap "broadcast_to(ndarray)" args -> IO [NDArrayHandle]+broadcast_to args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_to"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_to_upd ::+                 forall args . Fullfilled "broadcast_to(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "broadcast_to(ndarray)" args -> IO ()+broadcast_to_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_to"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_broadcast_backward(ndarray)" = '[]++_broadcast_backward ::+                    forall args . Fullfilled "_broadcast_backward(ndarray)" args =>+                      ArgsHMap "_broadcast_backward(ndarray)" args -> IO [NDArrayHandle]+_broadcast_backward args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_broadcast_backward"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_broadcast_backward_upd ::+                        forall args . Fullfilled "_broadcast_backward(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_broadcast_backward(ndarray)" args -> IO ()+_broadcast_backward_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_broadcast_backward"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "broadcast_like(ndarray)" =+     '[ '("lhs_axes", AttrOpt (Maybe [Int])),+        '("rhs_axes", AttrOpt (Maybe [Int])),+        '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]++broadcast_like ::+               forall args . Fullfilled "broadcast_like(ndarray)" args =>+                 ArgsHMap "broadcast_like(ndarray)" args -> IO [NDArrayHandle]+broadcast_like args+  = let scalarArgs+          = catMaybes+              [("lhs_axes",) . showValue <$>+                 (args !? #lhs_axes :: Maybe (Maybe [Int])),+               ("rhs_axes",) . showValue <$>+                 (args !? #rhs_axes :: Maybe (Maybe [Int]))]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++broadcast_like_upd ::+                   forall args . Fullfilled "broadcast_like(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "broadcast_like(ndarray)" args -> IO ()+broadcast_like_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lhs_axes",) . showValue <$>+                 (args !? #lhs_axes :: Maybe (Maybe [Int])),+               ("rhs_axes",) . showValue <$>+                 (args !? #rhs_axes :: Maybe (Maybe [Int]))]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "norm(ndarray)" =+     '[ '("ord", AttrOpt Int), '("axis", AttrOpt (Maybe [Int])),+        '("out_dtype",+          AttrOpt+            (Maybe+               (EnumType+                  '["float16", "float32", "float64", "int32", "int64", "int8"]))),+        '("keepdims", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++norm ::+     forall args . Fullfilled "norm(ndarray)" args =>+       ArgsHMap "norm(ndarray)" args -> IO [NDArrayHandle]+norm args+  = let scalarArgs+          = catMaybes+              [("ord",) . showValue <$> (args !? #ord :: Maybe Int),+               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("out_dtype",) . showValue <$>+                 (args !? #out_dtype ::+                    Maybe+                      (Maybe+                         (EnumType+                            '["float16", "float32", "float64", "int32", "int64", "int8"]))),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "norm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++norm_upd ::+         forall args . Fullfilled "norm(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "norm(ndarray)" args -> IO ()+norm_upd outputs args+  = let scalarArgs+          = catMaybes+              [("ord",) . showValue <$> (args !? #ord :: Maybe Int),+               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("out_dtype",) . showValue <$>+                 (args !? #out_dtype ::+                    Maybe+                      (Maybe+                         (EnumType+                            '["float16", "float32", "float64", "int32", "int64", "int8"]))),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "norm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_norm(ndarray)" = '[]++_backward_norm ::+               forall args . Fullfilled "_backward_norm(ndarray)" args =>+                 ArgsHMap "_backward_norm(ndarray)" args -> IO [NDArrayHandle]+_backward_norm args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_norm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_norm_upd ::+                   forall args . Fullfilled "_backward_norm(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_norm(ndarray)" args -> IO ()+_backward_norm_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_norm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "argmax(ndarray)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),+        '("data", AttrOpt NDArrayHandle)]++argmax ::+       forall args . Fullfilled "argmax(ndarray)" args =>+         ArgsHMap "argmax(ndarray)" args -> IO [NDArrayHandle]+argmax args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++argmax_upd ::+           forall args . Fullfilled "argmax(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "argmax(ndarray)" args -> IO ()+argmax_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "argmin(ndarray)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),+        '("data", AttrOpt NDArrayHandle)]++argmin ::+       forall args . Fullfilled "argmin(ndarray)" args =>+         ArgsHMap "argmin(ndarray)" args -> IO [NDArrayHandle]+argmin args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++argmin_upd ::+           forall args . Fullfilled "argmin(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "argmin(ndarray)" args -> IO ()+argmin_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "argmax_channel(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++argmax_channel ::+               forall args . Fullfilled "argmax_channel(ndarray)" args =>+                 ArgsHMap "argmax_channel(ndarray)" args -> IO [NDArrayHandle]+argmax_channel args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmax_channel"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++argmax_channel_upd ::+                   forall args . Fullfilled "argmax_channel(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "argmax_channel(ndarray)" args -> IO ()+argmax_channel_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmax_channel"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "pick(ndarray)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),+        '("mode", AttrOpt (EnumType '["clip", "wrap"])),+        '("data", AttrOpt NDArrayHandle),+        '("index", AttrOpt NDArrayHandle)]++pick ::+     forall args . Fullfilled "pick(ndarray)" args =>+       ArgsHMap "pick(ndarray)" args -> IO [NDArrayHandle]+pick args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["clip", "wrap"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("index",) <$> (args !? #index :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "pick"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++pick_upd ::+         forall args . Fullfilled "pick(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "pick(ndarray)" args -> IO ()+pick_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["clip", "wrap"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("index",) <$> (args !? #index :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "pick"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_pick(ndarray)" = '[]++_backward_pick ::+               forall args . Fullfilled "_backward_pick(ndarray)" args =>+                 ArgsHMap "_backward_pick(ndarray)" args -> IO [NDArrayHandle]+_backward_pick args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_pick"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_pick_upd ::+                   forall args . Fullfilled "_backward_pick(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_pick(ndarray)" args -> IO ()+_backward_pick_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_pick"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_sparse_retain(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle),+        '("indices", AttrOpt NDArrayHandle)]++_sparse_retain ::+               forall args . Fullfilled "_sparse_retain(ndarray)" args =>+                 ArgsHMap "_sparse_retain(ndarray)" args -> IO [NDArrayHandle]+_sparse_retain args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sparse_retain"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sparse_retain_upd ::+                   forall args . Fullfilled "_sparse_retain(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_sparse_retain(ndarray)" args -> IO ()+_sparse_retain_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sparse_retain"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_sparse_retain(ndarray)" =+     '[]++_backward_sparse_retain ::+                        forall args . Fullfilled "_backward_sparse_retain(ndarray)" args =>+                          ArgsHMap "_backward_sparse_retain(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_sparse_retain args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sparse_retain"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_sparse_retain_upd ::+                            forall args . Fullfilled "_backward_sparse_retain(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_sparse_retain(ndarray)" args -> IO ()+_backward_sparse_retain_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sparse_retain"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_where(ndarray)" =+     '[ '("condition", AttrOpt NDArrayHandle),+        '("x", AttrOpt NDArrayHandle), '("y", AttrOpt NDArrayHandle)]++_where ::+       forall args . Fullfilled "_where(ndarray)" args =>+         ArgsHMap "_where(ndarray)" args -> IO [NDArrayHandle]+_where args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("condition",) <$> (args !? #condition :: Maybe NDArrayHandle),+               ("x",) <$> (args !? #x :: Maybe NDArrayHandle),+               ("y",) <$> (args !? #y :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "where"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_where_upd ::+           forall args . Fullfilled "_where(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "_where(ndarray)" args -> IO ()+_where_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("condition",) <$> (args !? #condition :: Maybe NDArrayHandle),+               ("x",) <$> (args !? #x :: Maybe NDArrayHandle),+               ("y",) <$> (args !? #y :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "where"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_where(ndarray)" = '[]++_backward_where ::+                forall args . Fullfilled "_backward_where(ndarray)" args =>+                  ArgsHMap "_backward_where(ndarray)" args -> IO [NDArrayHandle]+_backward_where args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_where"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_where_upd ::+                    forall args . Fullfilled "_backward_where(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_where(ndarray)" args -> IO ()+_backward_where_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_where"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "diag(ndarray)" =+     '[ '("k", AttrOpt Int), '("axis1", AttrOpt Int),+        '("axis2", AttrOpt Int), '("data", AttrOpt NDArrayHandle)]++diag ::+     forall args . Fullfilled "diag(ndarray)" args =>+       ArgsHMap "diag(ndarray)" args -> IO [NDArrayHandle]+diag args+  = let scalarArgs+          = catMaybes+              [("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("axis1",) . showValue <$> (args !? #axis1 :: Maybe Int),+               ("axis2",) . showValue <$> (args !? #axis2 :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "diag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++diag_upd ::+         forall args . Fullfilled "diag(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "diag(ndarray)" args -> IO ()+diag_upd outputs args+  = let scalarArgs+          = catMaybes+              [("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("axis1",) . showValue <$> (args !? #axis1 :: Maybe Int),+               ("axis2",) . showValue <$> (args !? #axis2 :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "diag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_diag(ndarray)" = '[]++_backward_diag ::+               forall args . Fullfilled "_backward_diag(ndarray)" args =>+                 ArgsHMap "_backward_diag(ndarray)" args -> IO [NDArrayHandle]+_backward_diag args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_diag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_diag_upd ::+                   forall args . Fullfilled "_backward_diag(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_diag(ndarray)" args -> IO ()+_backward_diag_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_diag"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_maximum_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_maximum_scalar ::+                forall args . Fullfilled "_maximum_scalar(ndarray)" args =>+                  ArgsHMap "_maximum_scalar(ndarray)" args -> IO [NDArrayHandle]+_maximum_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_maximum_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_maximum_scalar_upd ::+                    forall args . Fullfilled "_maximum_scalar(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_maximum_scalar(ndarray)" args -> IO ()+_maximum_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_maximum_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_maximum_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_maximum_scalar ::+                         forall args .+                           Fullfilled "_backward_maximum_scalar(ndarray)" args =>+                           ArgsHMap "_backward_maximum_scalar(ndarray)" args ->+                             IO [NDArrayHandle]+_backward_maximum_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_maximum_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_maximum_scalar_upd ::+                             forall args .+                               Fullfilled "_backward_maximum_scalar(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_backward_maximum_scalar(ndarray)" args -> IO ()+_backward_maximum_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_maximum_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_minimum_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_minimum_scalar ::+                forall args . Fullfilled "_minimum_scalar(ndarray)" args =>+                  ArgsHMap "_minimum_scalar(ndarray)" args -> IO [NDArrayHandle]+_minimum_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minimum_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_minimum_scalar_upd ::+                    forall args . Fullfilled "_minimum_scalar(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_minimum_scalar(ndarray)" args -> IO ()+_minimum_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minimum_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_minimum_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_minimum_scalar ::+                         forall args .+                           Fullfilled "_backward_minimum_scalar(ndarray)" args =>+                           ArgsHMap "_backward_minimum_scalar(ndarray)" args ->+                             IO [NDArrayHandle]+_backward_minimum_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_minimum_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_minimum_scalar_upd ::+                             forall args .+                               Fullfilled "_backward_minimum_scalar(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_backward_minimum_scalar(ndarray)" args -> IO ()+_backward_minimum_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_minimum_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_power_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_power_scalar ::+              forall args . Fullfilled "_power_scalar(ndarray)" args =>+                ArgsHMap "_power_scalar(ndarray)" args -> IO [NDArrayHandle]+_power_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_power_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_power_scalar_upd ::+                  forall args . Fullfilled "_power_scalar(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_power_scalar(ndarray)" args -> IO ()+_power_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_power_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_power_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_power_scalar ::+                       forall args . Fullfilled "_backward_power_scalar(ndarray)" args =>+                         ArgsHMap "_backward_power_scalar(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_power_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_power_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_power_scalar_upd ::+                           forall args . Fullfilled "_backward_power_scalar(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_power_scalar(ndarray)" args -> IO ()+_backward_power_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_power_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_rpower_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_rpower_scalar ::+               forall args . Fullfilled "_rpower_scalar(ndarray)" args =>+                 ArgsHMap "_rpower_scalar(ndarray)" args -> IO [NDArrayHandle]+_rpower_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rpower_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_rpower_scalar_upd ::+                   forall args . Fullfilled "_rpower_scalar(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_rpower_scalar(ndarray)" args -> IO ()+_rpower_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rpower_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_rpower_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_rpower_scalar ::+                        forall args . Fullfilled "_backward_rpower_scalar(ndarray)" args =>+                          ArgsHMap "_backward_rpower_scalar(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_rpower_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rpower_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_rpower_scalar_upd ::+                            forall args . Fullfilled "_backward_rpower_scalar(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_rpower_scalar(ndarray)" args -> IO ()+_backward_rpower_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rpower_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_hypot_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_hypot_scalar ::+              forall args . Fullfilled "_hypot_scalar(ndarray)" args =>+                ArgsHMap "_hypot_scalar(ndarray)" args -> IO [NDArrayHandle]+_hypot_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_hypot_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_hypot_scalar_upd ::+                  forall args . Fullfilled "_hypot_scalar(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_hypot_scalar(ndarray)" args -> IO ()+_hypot_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_hypot_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_hypot_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_hypot_scalar ::+                       forall args . Fullfilled "_backward_hypot_scalar(ndarray)" args =>+                         ArgsHMap "_backward_hypot_scalar(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_hypot_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_hypot_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_hypot_scalar_upd ::+                           forall args . Fullfilled "_backward_hypot_scalar(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_hypot_scalar(ndarray)" args -> IO ()+_backward_hypot_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_hypot_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "smooth_l1(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++smooth_l1 ::+          forall args . Fullfilled "smooth_l1(ndarray)" args =>+            ArgsHMap "smooth_l1(ndarray)" args -> IO [NDArrayHandle]+smooth_l1 args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "smooth_l1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++smooth_l1_upd ::+              forall args . Fullfilled "smooth_l1(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "smooth_l1(ndarray)" args -> IO ()+smooth_l1_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "smooth_l1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_smooth_l1(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_smooth_l1 ::+                    forall args . Fullfilled "_backward_smooth_l1(ndarray)" args =>+                      ArgsHMap "_backward_smooth_l1(ndarray)" args -> IO [NDArrayHandle]+_backward_smooth_l1 args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_smooth_l1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_smooth_l1_upd ::+                        forall args . Fullfilled "_backward_smooth_l1(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_backward_smooth_l1(ndarray)" args -> IO ()+_backward_smooth_l1_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_smooth_l1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "topk(ndarray)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("k", AttrOpt Int),+        '("ret_typ",+          AttrOpt (EnumType '["both", "indices", "mask", "value"])),+        '("is_ascend", AttrOpt Bool),+        '("dtype",+          AttrOpt+            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),+        '("data", AttrOpt NDArrayHandle)]++topk ::+     forall args . Fullfilled "topk(ndarray)" args =>+       ArgsHMap "topk(ndarray)" args -> IO [NDArrayHandle]+topk args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("ret_typ",) . showValue <$>+                 (args !? #ret_typ ::+                    Maybe (EnumType '["both", "indices", "mask", "value"])),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "topk"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++topk_upd ::+         forall args . Fullfilled "topk(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "topk(ndarray)" args -> IO ()+topk_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("ret_typ",) . showValue <$>+                 (args !? #ret_typ ::+                    Maybe (EnumType '["both", "indices", "mask", "value"])),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "topk"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_topk(ndarray)" = '[]++_backward_topk ::+               forall args . Fullfilled "_backward_topk(ndarray)" args =>+                 ArgsHMap "_backward_topk(ndarray)" args -> IO [NDArrayHandle]+_backward_topk args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_topk"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_topk_upd ::+                   forall args . Fullfilled "_backward_topk(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_topk(ndarray)" args -> IO ()+_backward_topk_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_topk"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "sort(ndarray)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),+        '("data", AttrOpt NDArrayHandle)]++sort ::+     forall args . Fullfilled "sort(ndarray)" args =>+       ArgsHMap "sort(ndarray)" args -> IO [NDArrayHandle]+sort args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sort"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++sort_upd ::+         forall args . Fullfilled "sort(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "sort(ndarray)" args -> IO ()+sort_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sort"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "argsort(ndarray)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),+        '("dtype",+          AttrOpt+            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),+        '("data", AttrOpt NDArrayHandle)]++argsort ::+        forall args . Fullfilled "argsort(ndarray)" args =>+          ArgsHMap "argsort(ndarray)" args -> IO [NDArrayHandle]+argsort args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argsort"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++argsort_upd ::+            forall args . Fullfilled "argsort(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "argsort(ndarray)" args -> IO ()+argsort_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argsort"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Reshape(ndarray)" =+     '[ '("shape", AttrOpt [Int]), '("reverse", AttrOpt Bool),+        '("target_shape", AttrOpt [Int]), '("keep_highest", AttrOpt Bool),+        '("data", AttrOpt NDArrayHandle)]++_Reshape ::+         forall args . Fullfilled "_Reshape(ndarray)" args =>+           ArgsHMap "_Reshape(ndarray)" args -> IO [NDArrayHandle]+_Reshape args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("keep_highest",) . showValue <$>+                 (args !? #keep_highest :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Reshape"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Reshape_upd ::+             forall args . Fullfilled "_Reshape(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "_Reshape(ndarray)" args -> IO ()+_Reshape_upd outputs args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("keep_highest",) . showValue <$>+                 (args !? #keep_highest :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Reshape"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Flatten(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_Flatten ::+         forall args . Fullfilled "_Flatten(ndarray)" args =>+           ArgsHMap "_Flatten(ndarray)" args -> IO [NDArrayHandle]+_Flatten args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Flatten"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Flatten_upd ::+             forall args . Fullfilled "_Flatten(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "_Flatten(ndarray)" args -> IO ()+_Flatten_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Flatten"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "transpose(ndarray)" =+     '[ '("axes", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]++transpose ::+          forall args . Fullfilled "transpose(ndarray)" args =>+            ArgsHMap "transpose(ndarray)" args -> IO [NDArrayHandle]+transpose args+  = let scalarArgs+          = catMaybes+              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "transpose"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++transpose_upd ::+              forall args . Fullfilled "transpose(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "transpose(ndarray)" args -> IO ()+transpose_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "transpose"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "expand_dims(ndarray)" =+     '[ '("axis", AttrReq Int), '("data", AttrOpt NDArrayHandle)]++expand_dims ::+            forall args . Fullfilled "expand_dims(ndarray)" args =>+              ArgsHMap "expand_dims(ndarray)" args -> IO [NDArrayHandle]+expand_dims args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "expand_dims"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++expand_dims_upd ::+                forall args . Fullfilled "expand_dims(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "expand_dims(ndarray)" args -> IO ()+expand_dims_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "expand_dims"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "slice(ndarray)" =+     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),+        '("step", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]++slice ::+      forall args . Fullfilled "slice(ndarray)" args =>+        ArgsHMap "slice(ndarray)" args -> IO [NDArrayHandle]+slice args+  = let scalarArgs+          = catMaybes+              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "slice"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++slice_upd ::+          forall args . Fullfilled "slice(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "slice(ndarray)" args -> IO ()+slice_upd outputs args+  = let scalarArgs+          = catMaybes+              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "slice"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_slice(ndarray)" = '[]++_backward_slice ::+                forall args . Fullfilled "_backward_slice(ndarray)" args =>+                  ArgsHMap "_backward_slice(ndarray)" args -> IO [NDArrayHandle]+_backward_slice args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_slice"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_slice_upd ::+                    forall args . Fullfilled "_backward_slice(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_slice(ndarray)" args -> IO ()+_backward_slice_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_slice"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_slice_assign(ndarray)" =+     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),+        '("step", AttrOpt [Int]), '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_slice_assign ::+              forall args . Fullfilled "_slice_assign(ndarray)" args =>+                ArgsHMap "_slice_assign(ndarray)" args -> IO [NDArrayHandle]+_slice_assign args+  = let scalarArgs+          = catMaybes+              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_slice_assign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_slice_assign_upd ::+                  forall args . Fullfilled "_slice_assign(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_slice_assign(ndarray)" args -> IO ()+_slice_assign_upd outputs args+  = let scalarArgs+          = catMaybes+              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_slice_assign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_slice_assign_scalar(ndarray)" =+     '[ '("scalar", AttrOpt Double), '("begin", AttrReq [Int]),+        '("end", AttrReq [Int]), '("step", AttrOpt [Int]),+        '("data", AttrOpt NDArrayHandle)]++_slice_assign_scalar ::+                     forall args . Fullfilled "_slice_assign_scalar(ndarray)" args =>+                       ArgsHMap "_slice_assign_scalar(ndarray)" args -> IO [NDArrayHandle]+_slice_assign_scalar args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Double),+               ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_slice_assign_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_slice_assign_scalar_upd ::+                         forall args . Fullfilled "_slice_assign_scalar(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_slice_assign_scalar(ndarray)" args -> IO ()+_slice_assign_scalar_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Double),+               ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_slice_assign_scalar"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "slice_axis(ndarray)" =+     '[ '("axis", AttrReq Int), '("begin", AttrReq Int),+        '("end", AttrReq (Maybe Int)), '("data", AttrOpt NDArrayHandle)]++slice_axis ::+           forall args . Fullfilled "slice_axis(ndarray)" args =>+             ArgsHMap "slice_axis(ndarray)" args -> IO [NDArrayHandle]+slice_axis args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("begin",) . showValue <$> (args !? #begin :: Maybe Int),+               ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "slice_axis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++slice_axis_upd ::+               forall args . Fullfilled "slice_axis(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "slice_axis(ndarray)" args -> IO ()+slice_axis_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("begin",) . showValue <$> (args !? #begin :: Maybe Int),+               ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "slice_axis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_slice_axis(ndarray)" = '[]++_backward_slice_axis ::+                     forall args . Fullfilled "_backward_slice_axis(ndarray)" args =>+                       ArgsHMap "_backward_slice_axis(ndarray)" args -> IO [NDArrayHandle]+_backward_slice_axis args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_slice_axis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_slice_axis_upd ::+                         forall args . Fullfilled "_backward_slice_axis(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_slice_axis(ndarray)" args -> IO ()+_backward_slice_axis_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_slice_axis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "slice_like(ndarray)" =+     '[ '("axes", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle),+        '("shape_like", AttrOpt NDArrayHandle)]++slice_like ::+           forall args . Fullfilled "slice_like(ndarray)" args =>+             ArgsHMap "slice_like(ndarray)" args -> IO [NDArrayHandle]+slice_like args+  = let scalarArgs+          = catMaybes+              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("shape_like",) <$> (args !? #shape_like :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "slice_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++slice_like_upd ::+               forall args . Fullfilled "slice_like(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "slice_like(ndarray)" args -> IO ()+slice_like_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("shape_like",) <$> (args !? #shape_like :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "slice_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_slice_like(ndarray)" = '[]++_backward_slice_like ::+                     forall args . Fullfilled "_backward_slice_like(ndarray)" args =>+                       ArgsHMap "_backward_slice_like(ndarray)" args -> IO [NDArrayHandle]+_backward_slice_like args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_slice_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_slice_like_upd ::+                         forall args . Fullfilled "_backward_slice_like(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_slice_like(ndarray)" args -> IO ()+_backward_slice_like_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_slice_like"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "clip(ndarray)" =+     '[ '("a_min", AttrReq Float), '("a_max", AttrReq Float),+        '("data", AttrOpt NDArrayHandle)]++clip ::+     forall args . Fullfilled "clip(ndarray)" args =>+       ArgsHMap "clip(ndarray)" args -> IO [NDArrayHandle]+clip args+  = let scalarArgs+          = catMaybes+              [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float),+               ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "clip"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++clip_upd ::+         forall args . Fullfilled "clip(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "clip(ndarray)" args -> IO ()+clip_upd outputs args+  = let scalarArgs+          = catMaybes+              [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float),+               ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "clip"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_clip(ndarray)" = '[]++_backward_clip ::+               forall args . Fullfilled "_backward_clip(ndarray)" args =>+                 ArgsHMap "_backward_clip(ndarray)" args -> IO [NDArrayHandle]+_backward_clip args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_clip"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_clip_upd ::+                   forall args . Fullfilled "_backward_clip(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_clip(ndarray)" args -> IO ()+_backward_clip_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_clip"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "repeat(ndarray)" =+     '[ '("repeats", AttrReq Int), '("axis", AttrOpt (Maybe Int)),+        '("data", AttrOpt NDArrayHandle)]++repeat ::+       forall args . Fullfilled "repeat(ndarray)" args =>+         ArgsHMap "repeat(ndarray)" args -> IO [NDArrayHandle]+repeat args+  = let scalarArgs+          = catMaybes+              [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int),+               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "repeat"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++repeat_upd ::+           forall args . Fullfilled "repeat(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "repeat(ndarray)" args -> IO ()+repeat_upd outputs args+  = let scalarArgs+          = catMaybes+              [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int),+               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "repeat"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_repeat(ndarray)" = '[]++_backward_repeat ::+                 forall args . Fullfilled "_backward_repeat(ndarray)" args =>+                   ArgsHMap "_backward_repeat(ndarray)" args -> IO [NDArrayHandle]+_backward_repeat args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_repeat"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_repeat_upd ::+                     forall args . Fullfilled "_backward_repeat(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_backward_repeat(ndarray)" args -> IO ()+_backward_repeat_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_repeat"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "tile(ndarray)" =+     '[ '("reps", AttrReq [Int]), '("data", AttrOpt NDArrayHandle)]++tile ::+     forall args . Fullfilled "tile(ndarray)" args =>+       ArgsHMap "tile(ndarray)" args -> IO [NDArrayHandle]+tile args+  = let scalarArgs+          = catMaybes+              [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tile"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++tile_upd ::+         forall args . Fullfilled "tile(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "tile(ndarray)" args -> IO ()+tile_upd outputs args+  = let scalarArgs+          = catMaybes+              [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tile"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_tile(ndarray)" = '[]++_backward_tile ::+               forall args . Fullfilled "_backward_tile(ndarray)" args =>+                 ArgsHMap "_backward_tile(ndarray)" args -> IO [NDArrayHandle]+_backward_tile args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tile"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_tile_upd ::+                   forall args . Fullfilled "_backward_tile(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_tile(ndarray)" args -> IO ()+_backward_tile_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tile"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "reverse(ndarray)" =+     '[ '("axis", AttrReq [Int]), '("data", AttrOpt NDArrayHandle)]++reverse ::+        forall args . Fullfilled "reverse(ndarray)" args =>+          ArgsHMap "reverse(ndarray)" args -> IO [NDArrayHandle]+reverse args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reverse"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++reverse_upd ::+            forall args . Fullfilled "reverse(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "reverse(ndarray)" args -> IO ()+reverse_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reverse"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_reverse(ndarray)" = '[]++_backward_reverse ::+                  forall args . Fullfilled "_backward_reverse(ndarray)" args =>+                    ArgsHMap "_backward_reverse(ndarray)" args -> IO [NDArrayHandle]+_backward_reverse args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_reverse"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_reverse_upd ::+                      forall args . Fullfilled "_backward_reverse(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_reverse(ndarray)" args -> IO ()+_backward_reverse_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_reverse"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "stack(ndarray)" =+     '[ '("axis", AttrOpt Int), '("num_args", AttrReq Int),+        '("data", AttrOpt [NDArrayHandle])]++stack ::+      forall args . Fullfilled "stack(ndarray)" args =>+        ArgsHMap "stack(ndarray)" args -> IO [NDArrayHandle]+stack args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "stack"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        Nothing+         return listndarr++stack_upd ::+          forall args . Fullfilled "stack(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "stack(ndarray)" args -> IO ()+stack_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "stack"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        (Just outputs)+         return ()++type instance ParameterList "_backward_stack(ndarray)" = '[]++_backward_stack ::+                forall args . Fullfilled "_backward_stack(ndarray)" args =>+                  ArgsHMap "_backward_stack(ndarray)" args -> IO [NDArrayHandle]+_backward_stack args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_stack"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_stack_upd ::+                    forall args . Fullfilled "_backward_stack(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_backward_stack(ndarray)" args -> IO ()+_backward_stack_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_stack"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "squeeze(ndarray)" =+     '[ '("axis", AttrOpt (Maybe [Int])),+        '("data", AttrOpt [NDArrayHandle])]++squeeze ::+        forall args . Fullfilled "squeeze(ndarray)" args =>+          ArgsHMap "squeeze(ndarray)" args -> IO [NDArrayHandle]+squeeze args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "squeeze"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++squeeze_upd ::+            forall args . Fullfilled "squeeze(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "squeeze(ndarray)" args -> IO ()+squeeze_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "squeeze"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_squeeze(ndarray)" = '[]++_backward_squeeze ::+                  forall args . Fullfilled "_backward_squeeze(ndarray)" args =>+                    ArgsHMap "_backward_squeeze(ndarray)" args -> IO [NDArrayHandle]+_backward_squeeze args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_squeeze"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_squeeze_upd ::+                      forall args . Fullfilled "_backward_squeeze(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_squeeze(ndarray)" args -> IO ()+_backward_squeeze_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_squeeze"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "depth_to_space(ndarray)" =+     '[ '("block_size", AttrReq Int), '("data", AttrOpt NDArrayHandle)]++depth_to_space ::+               forall args . Fullfilled "depth_to_space(ndarray)" args =>+                 ArgsHMap "depth_to_space(ndarray)" args -> IO [NDArrayHandle]+depth_to_space args+  = let scalarArgs+          = catMaybes+              [("block_size",) . showValue <$>+                 (args !? #block_size :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "depth_to_space"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++depth_to_space_upd ::+                   forall args . Fullfilled "depth_to_space(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "depth_to_space(ndarray)" args -> IO ()+depth_to_space_upd outputs args+  = let scalarArgs+          = catMaybes+              [("block_size",) . showValue <$>+                 (args !? #block_size :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "depth_to_space"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "space_to_depth(ndarray)" =+     '[ '("block_size", AttrReq Int), '("data", AttrOpt NDArrayHandle)]++space_to_depth ::+               forall args . Fullfilled "space_to_depth(ndarray)" args =>+                 ArgsHMap "space_to_depth(ndarray)" args -> IO [NDArrayHandle]+space_to_depth args+  = let scalarArgs+          = catMaybes+              [("block_size",) . showValue <$>+                 (args !? #block_size :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "space_to_depth"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++space_to_depth_upd ::+                   forall args . Fullfilled "space_to_depth(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "space_to_depth(ndarray)" args -> IO ()+space_to_depth_upd outputs args+  = let scalarArgs+          = catMaybes+              [("block_size",) . showValue <$>+                 (args !? #block_size :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "space_to_depth"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_split_v2(ndarray)" =+     '[ '("indices", AttrReq [Int]), '("axis", AttrOpt Int),+        '("squeeze_axis", AttrOpt Bool), '("sections", AttrOpt Int),+        '("data", AttrOpt NDArrayHandle)]++_split_v2 ::+          forall args . Fullfilled "_split_v2(ndarray)" args =>+            ArgsHMap "_split_v2(ndarray)" args -> IO [NDArrayHandle]+_split_v2 args+  = let scalarArgs+          = catMaybes+              [("indices",) . showValue <$> (args !? #indices :: Maybe [Int]),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("squeeze_axis",) . showValue <$>+                 (args !? #squeeze_axis :: Maybe Bool),+               ("sections",) . showValue <$> (args !? #sections :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_split_v2"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_split_v2_upd ::+              forall args . Fullfilled "_split_v2(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "_split_v2(ndarray)" args -> IO ()+_split_v2_upd outputs args+  = let scalarArgs+          = catMaybes+              [("indices",) . showValue <$> (args !? #indices :: Maybe [Int]),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("squeeze_axis",) . showValue <$>+                 (args !? #squeeze_axis :: Maybe Bool),+               ("sections",) . showValue <$> (args !? #sections :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_split_v2"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_split_v2_backward(ndarray)" = '[]++_split_v2_backward ::+                   forall args . Fullfilled "_split_v2_backward(ndarray)" args =>+                     ArgsHMap "_split_v2_backward(ndarray)" args -> IO [NDArrayHandle]+_split_v2_backward args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_split_v2_backward"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_split_v2_backward_upd ::+                       forall args . Fullfilled "_split_v2_backward(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_split_v2_backward(ndarray)" args -> IO ()+_split_v2_backward_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_split_v2_backward"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "dot(ndarray)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("forward_stype",+          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))),+        '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]++dot ::+    forall args . Fullfilled "dot(ndarray)" args =>+      ArgsHMap "dot(ndarray)" args -> IO [NDArrayHandle]+dot args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("forward_stype",) . showValue <$>+                 (args !? #forward_stype ::+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "dot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++dot_upd ::+        forall args . Fullfilled "dot(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "dot(ndarray)" args -> IO ()+dot_upd outputs args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("forward_stype",) . showValue <$>+                 (args !? #forward_stype ::+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "dot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_dot(ndarray)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("forward_stype",+          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"])))]++_backward_dot ::+              forall args . Fullfilled "_backward_dot(ndarray)" args =>+                ArgsHMap "_backward_dot(ndarray)" args -> IO [NDArrayHandle]+_backward_dot args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("forward_stype",) . showValue <$>+                 (args !? #forward_stype ::+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_dot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_dot_upd ::+                  forall args . Fullfilled "_backward_dot(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_dot(ndarray)" args -> IO ()+_backward_dot_upd outputs args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("forward_stype",) . showValue <$>+                 (args !? #forward_stype ::+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_dot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "batch_dot(ndarray)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("forward_stype",+          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))),+        '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]++batch_dot ::+          forall args . Fullfilled "batch_dot(ndarray)" args =>+            ArgsHMap "batch_dot(ndarray)" args -> IO [NDArrayHandle]+batch_dot args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("forward_stype",) . showValue <$>+                 (args !? #forward_stype ::+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "batch_dot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++batch_dot_upd ::+              forall args . Fullfilled "batch_dot(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "batch_dot(ndarray)" args -> IO ()+batch_dot_upd outputs args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("forward_stype",) . showValue <$>+                 (args !? #forward_stype ::+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "batch_dot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_batch_dot(ndarray)" = '[]++_backward_batch_dot ::+                    forall args . Fullfilled "_backward_batch_dot(ndarray)" args =>+                      ArgsHMap "_backward_batch_dot(ndarray)" args -> IO [NDArrayHandle]+_backward_batch_dot args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_batch_dot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_batch_dot_upd ::+                        forall args . Fullfilled "_backward_batch_dot(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_backward_batch_dot(ndarray)" args -> IO ()+_backward_batch_dot_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_batch_dot"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "sin(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++sin ::+    forall args . Fullfilled "sin(ndarray)" args =>+      ArgsHMap "sin(ndarray)" args -> IO [NDArrayHandle]+sin args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++sin_upd ::+        forall args . Fullfilled "sin(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "sin(ndarray)" args -> IO ()+sin_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_sin(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_sin ::+              forall args . Fullfilled "_backward_sin(ndarray)" args =>+                ArgsHMap "_backward_sin(ndarray)" args -> IO [NDArrayHandle]+_backward_sin args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_sin_upd ::+                  forall args . Fullfilled "_backward_sin(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_sin(ndarray)" args -> IO ()+_backward_sin_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "cos(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++cos ::+    forall args . Fullfilled "cos(ndarray)" args =>+      ArgsHMap "cos(ndarray)" args -> IO [NDArrayHandle]+cos args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cos"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++cos_upd ::+        forall args . Fullfilled "cos(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "cos(ndarray)" args -> IO ()+cos_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cos"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_cos(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_cos ::+              forall args . Fullfilled "_backward_cos(ndarray)" args =>+                ArgsHMap "_backward_cos(ndarray)" args -> IO [NDArrayHandle]+_backward_cos args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cos"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_cos_upd ::+                  forall args . Fullfilled "_backward_cos(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_cos(ndarray)" args -> IO ()+_backward_cos_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cos"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "tan(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++tan ::+    forall args . Fullfilled "tan(ndarray)" args =>+      ArgsHMap "tan(ndarray)" args -> IO [NDArrayHandle]+tan args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tan"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++tan_upd ::+        forall args . Fullfilled "tan(ndarray)" args =>+          [NDArrayHandle] -> ArgsHMap "tan(ndarray)" args -> IO ()+tan_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tan"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_tan(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_tan ::+              forall args . Fullfilled "_backward_tan(ndarray)" args =>+                ArgsHMap "_backward_tan(ndarray)" args -> IO [NDArrayHandle]+_backward_tan args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tan"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_tan_upd ::+                  forall args . Fullfilled "_backward_tan(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_tan(ndarray)" args -> IO ()+_backward_tan_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tan"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "arcsin(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++arcsin ::+       forall args . Fullfilled "arcsin(ndarray)" args =>+         ArgsHMap "arcsin(ndarray)" args -> IO [NDArrayHandle]+arcsin args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arcsin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++arcsin_upd ::+           forall args . Fullfilled "arcsin(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "arcsin(ndarray)" args -> IO ()+arcsin_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arcsin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_arcsin(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_arcsin ::+                 forall args . Fullfilled "_backward_arcsin(ndarray)" args =>+                   ArgsHMap "_backward_arcsin(ndarray)" args -> IO [NDArrayHandle]+_backward_arcsin args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arcsin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_arcsin_upd ::+                     forall args . Fullfilled "_backward_arcsin(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_backward_arcsin(ndarray)" args -> IO ()+_backward_arcsin_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arcsin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "arccos(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++arccos ::+       forall args . Fullfilled "arccos(ndarray)" args =>+         ArgsHMap "arccos(ndarray)" args -> IO [NDArrayHandle]+arccos args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arccos"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++arccos_upd ::+           forall args . Fullfilled "arccos(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "arccos(ndarray)" args -> IO ()+arccos_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arccos"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_arccos(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_arccos ::+                 forall args . Fullfilled "_backward_arccos(ndarray)" args =>+                   ArgsHMap "_backward_arccos(ndarray)" args -> IO [NDArrayHandle]+_backward_arccos args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arccos"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_arccos_upd ::+                     forall args . Fullfilled "_backward_arccos(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_backward_arccos(ndarray)" args -> IO ()+_backward_arccos_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arccos"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "arctan(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++arctan ::+       forall args . Fullfilled "arctan(ndarray)" args =>+         ArgsHMap "arctan(ndarray)" args -> IO [NDArrayHandle]+arctan args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arctan"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++arctan_upd ::+           forall args . Fullfilled "arctan(ndarray)" args =>+             [NDArrayHandle] -> ArgsHMap "arctan(ndarray)" args -> IO ()+arctan_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arctan"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_arctan(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_arctan ::+                 forall args . Fullfilled "_backward_arctan(ndarray)" args =>+                   ArgsHMap "_backward_arctan(ndarray)" args -> IO [NDArrayHandle]+_backward_arctan args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arctan"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_arctan_upd ::+                     forall args . Fullfilled "_backward_arctan(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_backward_arctan(ndarray)" args -> IO ()+_backward_arctan_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arctan"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "degrees(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++degrees ::+        forall args . Fullfilled "degrees(ndarray)" args =>+          ArgsHMap "degrees(ndarray)" args -> IO [NDArrayHandle]+degrees args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "degrees"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++degrees_upd ::+            forall args . Fullfilled "degrees(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "degrees(ndarray)" args -> IO ()+degrees_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "degrees"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_degrees(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_degrees ::+                  forall args . Fullfilled "_backward_degrees(ndarray)" args =>+                    ArgsHMap "_backward_degrees(ndarray)" args -> IO [NDArrayHandle]+_backward_degrees args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_degrees"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_degrees_upd ::+                      forall args . Fullfilled "_backward_degrees(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_degrees(ndarray)" args -> IO ()+_backward_degrees_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_degrees"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "radians(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++radians ::+        forall args . Fullfilled "radians(ndarray)" args =>+          ArgsHMap "radians(ndarray)" args -> IO [NDArrayHandle]+radians args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "radians"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++radians_upd ::+            forall args . Fullfilled "radians(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "radians(ndarray)" args -> IO ()+radians_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "radians"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_radians(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_radians ::+                  forall args . Fullfilled "_backward_radians(ndarray)" args =>+                    ArgsHMap "_backward_radians(ndarray)" args -> IO [NDArrayHandle]+_backward_radians args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_radians"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_radians_upd ::+                      forall args . Fullfilled "_backward_radians(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_radians(ndarray)" args -> IO ()+_backward_radians_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_radians"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "sinh(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++sinh ::+     forall args . Fullfilled "sinh(ndarray)" args =>+       ArgsHMap "sinh(ndarray)" args -> IO [NDArrayHandle]+sinh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sinh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++sinh_upd ::+         forall args . Fullfilled "sinh(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "sinh(ndarray)" args -> IO ()+sinh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sinh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_sinh(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_sinh ::+               forall args . Fullfilled "_backward_sinh(ndarray)" args =>+                 ArgsHMap "_backward_sinh(ndarray)" args -> IO [NDArrayHandle]+_backward_sinh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sinh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_sinh_upd ::+                   forall args . Fullfilled "_backward_sinh(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_sinh(ndarray)" args -> IO ()+_backward_sinh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sinh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "cosh(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++cosh ::+     forall args . Fullfilled "cosh(ndarray)" args =>+       ArgsHMap "cosh(ndarray)" args -> IO [NDArrayHandle]+cosh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cosh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++cosh_upd ::+         forall args . Fullfilled "cosh(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "cosh(ndarray)" args -> IO ()+cosh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cosh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_cosh(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_cosh ::+               forall args . Fullfilled "_backward_cosh(ndarray)" args =>+                 ArgsHMap "_backward_cosh(ndarray)" args -> IO [NDArrayHandle]+_backward_cosh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cosh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_cosh_upd ::+                   forall args . Fullfilled "_backward_cosh(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_cosh(ndarray)" args -> IO ()+_backward_cosh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cosh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "tanh(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++tanh ::+     forall args . Fullfilled "tanh(ndarray)" args =>+       ArgsHMap "tanh(ndarray)" args -> IO [NDArrayHandle]+tanh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tanh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++tanh_upd ::+         forall args . Fullfilled "tanh(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "tanh(ndarray)" args -> IO ()+tanh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tanh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_tanh(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_tanh ::+               forall args . Fullfilled "_backward_tanh(ndarray)" args =>+                 ArgsHMap "_backward_tanh(ndarray)" args -> IO [NDArrayHandle]+_backward_tanh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tanh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_tanh_upd ::+                   forall args . Fullfilled "_backward_tanh(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_tanh(ndarray)" args -> IO ()+_backward_tanh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tanh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "arcsinh(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++arcsinh ::+        forall args . Fullfilled "arcsinh(ndarray)" args =>+          ArgsHMap "arcsinh(ndarray)" args -> IO [NDArrayHandle]+arcsinh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arcsinh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++arcsinh_upd ::+            forall args . Fullfilled "arcsinh(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "arcsinh(ndarray)" args -> IO ()+arcsinh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arcsinh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_arcsinh(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_arcsinh ::+                  forall args . Fullfilled "_backward_arcsinh(ndarray)" args =>+                    ArgsHMap "_backward_arcsinh(ndarray)" args -> IO [NDArrayHandle]+_backward_arcsinh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arcsinh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_arcsinh_upd ::+                      forall args . Fullfilled "_backward_arcsinh(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_arcsinh(ndarray)" args -> IO ()+_backward_arcsinh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arcsinh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "arccosh(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++arccosh ::+        forall args . Fullfilled "arccosh(ndarray)" args =>+          ArgsHMap "arccosh(ndarray)" args -> IO [NDArrayHandle]+arccosh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arccosh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++arccosh_upd ::+            forall args . Fullfilled "arccosh(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "arccosh(ndarray)" args -> IO ()+arccosh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arccosh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_arccosh(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_arccosh ::+                  forall args . Fullfilled "_backward_arccosh(ndarray)" args =>+                    ArgsHMap "_backward_arccosh(ndarray)" args -> IO [NDArrayHandle]+_backward_arccosh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arccosh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_arccosh_upd ::+                      forall args . Fullfilled "_backward_arccosh(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_arccosh(ndarray)" args -> IO ()+_backward_arccosh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arccosh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "arctanh(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++arctanh ::+        forall args . Fullfilled "arctanh(ndarray)" args =>+          ArgsHMap "arctanh(ndarray)" args -> IO [NDArrayHandle]+arctanh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arctanh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++arctanh_upd ::+            forall args . Fullfilled "arctanh(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "arctanh(ndarray)" args -> IO ()+arctanh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arctanh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_arctanh(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_backward_arctanh ::+                  forall args . Fullfilled "_backward_arctanh(ndarray)" args =>+                    ArgsHMap "_backward_arctanh(ndarray)" args -> IO [NDArrayHandle]+_backward_arctanh args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arctanh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_arctanh_upd ::+                      forall args . Fullfilled "_backward_arctanh(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_arctanh(ndarray)" args -> IO ()+_backward_arctanh_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arctanh"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "khatri_rao(ndarray)" =+     '[ '("args", AttrOpt [NDArrayHandle])]++khatri_rao ::+           forall args . Fullfilled "khatri_rao(ndarray)" args =>+             ArgsHMap "khatri_rao(ndarray)" args -> IO [NDArrayHandle]+khatri_rao args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "khatri_rao"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        Nothing+         return listndarr++khatri_rao_upd ::+               forall args . Fullfilled "khatri_rao(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "khatri_rao(ndarray)" args -> IO ()+khatri_rao_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "khatri_rao"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        (Just outputs)+         return ()++type instance+     ParameterList "_contrib_group_adagrad_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("epsilon", AttrOpt Float),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle),+        '("history", AttrOpt NDArrayHandle)]++_contrib_group_adagrad_update ::+                              forall args .+                                Fullfilled "_contrib_group_adagrad_update(ndarray)" args =>+                                ArgsHMap "_contrib_group_adagrad_update(ndarray)" args ->+                                  IO [NDArrayHandle]+_contrib_group_adagrad_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("history",) <$> (args !? #history :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_group_adagrad_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_group_adagrad_update_upd ::+                                  forall args .+                                    Fullfilled "_contrib_group_adagrad_update(ndarray)" args =>+                                    [NDArrayHandle] ->+                                      ArgsHMap "_contrib_group_adagrad_update(ndarray)" args ->+                                        IO ()+_contrib_group_adagrad_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("history",) <$> (args !? #history :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_group_adagrad_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_getnnz(ndarray)" =+     '[ '("axis", AttrOpt (Maybe Int)),+        '("data", AttrOpt NDArrayHandle)]++_contrib_getnnz ::+                forall args . Fullfilled "_contrib_getnnz(ndarray)" args =>+                  ArgsHMap "_contrib_getnnz(ndarray)" args -> IO [NDArrayHandle]+_contrib_getnnz args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_getnnz"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_getnnz_upd ::+                    forall args . Fullfilled "_contrib_getnnz(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_contrib_getnnz(ndarray)" args -> IO ()+_contrib_getnnz_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_getnnz"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_gradientmultiplier(ndarray)"+     = '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_contrib_gradientmultiplier ::+                            forall args .+                              Fullfilled "_contrib_gradientmultiplier(ndarray)" args =>+                              ArgsHMap "_contrib_gradientmultiplier(ndarray)" args ->+                                IO [NDArrayHandle]+_contrib_gradientmultiplier args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_gradientmultiplier"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_gradientmultiplier_upd ::+                                forall args .+                                  Fullfilled "_contrib_gradientmultiplier(ndarray)" args =>+                                  [NDArrayHandle] ->+                                    ArgsHMap "_contrib_gradientmultiplier(ndarray)" args -> IO ()+_contrib_gradientmultiplier_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_gradientmultiplier"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_contrib_backward_gradientmultiplier(ndarray)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_contrib_backward_gradientmultiplier ::+                                     forall args .+                                       Fullfilled "_contrib_backward_gradientmultiplier(ndarray)"+                                         args =>+                                       ArgsHMap "_contrib_backward_gradientmultiplier(ndarray)" args+                                         -> IO [NDArrayHandle]+_contrib_backward_gradientmultiplier args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_backward_gradientmultiplier"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_backward_gradientmultiplier_upd ::+                                         forall args .+                                           Fullfilled+                                             "_contrib_backward_gradientmultiplier(ndarray)" args =>+                                           [NDArrayHandle] ->+                                             ArgsHMap+                                               "_contrib_backward_gradientmultiplier(ndarray)"+                                               args+                                               -> IO ()+_contrib_backward_gradientmultiplier_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_backward_gradientmultiplier"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_edge_id(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle), '("u", AttrOpt NDArrayHandle),+        '("v", AttrOpt NDArrayHandle)]++_contrib_edge_id ::+                 forall args . Fullfilled "_contrib_edge_id(ndarray)" args =>+                   ArgsHMap "_contrib_edge_id(ndarray)" args -> IO [NDArrayHandle]+_contrib_edge_id args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("u",) <$> (args !? #u :: Maybe NDArrayHandle),+               ("v",) <$> (args !? #v :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_edge_id"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_edge_id_upd ::+                     forall args . Fullfilled "_contrib_edge_id(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_contrib_edge_id(ndarray)" args -> IO ()+_contrib_edge_id_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("u",) <$> (args !? #u :: Maybe NDArrayHandle),+               ("v",) <$> (args !? #v :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_edge_id"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_dgl_adjacency(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_contrib_dgl_adjacency ::+                       forall args . Fullfilled "_contrib_dgl_adjacency(ndarray)" args =>+                         ArgsHMap "_contrib_dgl_adjacency(ndarray)" args ->+                           IO [NDArrayHandle]+_contrib_dgl_adjacency args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_dgl_adjacency"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_dgl_adjacency_upd ::+                           forall args . Fullfilled "_contrib_dgl_adjacency(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_contrib_dgl_adjacency(ndarray)" args -> IO ()+_contrib_dgl_adjacency_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_dgl_adjacency"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_hawkesll(ndarray)" =+     '[ '("lda", AttrOpt NDArrayHandle),+        '("alpha", AttrOpt NDArrayHandle),+        '("beta", AttrOpt NDArrayHandle),+        '("state", AttrOpt NDArrayHandle),+        '("lags", AttrOpt NDArrayHandle),+        '("marks", AttrOpt NDArrayHandle),+        '("valid_length", AttrOpt NDArrayHandle),+        '("max_time", AttrOpt NDArrayHandle)]++_contrib_hawkesll ::+                  forall args . Fullfilled "_contrib_hawkesll(ndarray)" args =>+                    ArgsHMap "_contrib_hawkesll(ndarray)" args -> IO [NDArrayHandle]+_contrib_hawkesll args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lda",) <$> (args !? #lda :: Maybe NDArrayHandle),+               ("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),+               ("state",) <$> (args !? #state :: Maybe NDArrayHandle),+               ("lags",) <$> (args !? #lags :: Maybe NDArrayHandle),+               ("marks",) <$> (args !? #marks :: Maybe NDArrayHandle),+               ("valid_length",) <$>+                 (args !? #valid_length :: Maybe NDArrayHandle),+               ("max_time",) <$> (args !? #max_time :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_hawkesll"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_hawkesll_upd ::+                      forall args . Fullfilled "_contrib_hawkesll(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_contrib_hawkesll(ndarray)" args -> IO ()+_contrib_hawkesll_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lda",) <$> (args !? #lda :: Maybe NDArrayHandle),+               ("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),+               ("state",) <$> (args !? #state :: Maybe NDArrayHandle),+               ("lags",) <$> (args !? #lags :: Maybe NDArrayHandle),+               ("marks",) <$> (args !? #marks :: Maybe NDArrayHandle),+               ("valid_length",) <$>+                 (args !? #valid_length :: Maybe NDArrayHandle),+               ("max_time",) <$> (args !? #max_time :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_hawkesll"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_backward_hawkesll(ndarray)" =+     '[]++_contrib_backward_hawkesll ::+                           forall args .+                             Fullfilled "_contrib_backward_hawkesll(ndarray)" args =>+                             ArgsHMap "_contrib_backward_hawkesll(ndarray)" args ->+                               IO [NDArrayHandle]+_contrib_backward_hawkesll args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_backward_hawkesll"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_backward_hawkesll_upd ::+                               forall args .+                                 Fullfilled "_contrib_backward_hawkesll(ndarray)" args =>+                                 [NDArrayHandle] ->+                                   ArgsHMap "_contrib_backward_hawkesll(ndarray)" args -> IO ()+_contrib_backward_hawkesll_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_backward_hawkesll"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_mp_adamw_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),+        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float),+        '("wd", AttrOpt Float), '("eta", AttrReq Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle), '("mean", AttrOpt NDArrayHandle),+        '("var", AttrOpt NDArrayHandle),+        '("weight32", AttrOpt NDArrayHandle),+        '("rescale_grad", AttrOpt NDArrayHandle)]++_mp_adamw_update ::+                 forall args . Fullfilled "_mp_adamw_update(ndarray)" args =>+                   ArgsHMap "_mp_adamw_update(ndarray)" args -> IO [NDArrayHandle]+_mp_adamw_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("eta",) . showValue <$> (args !? #eta :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle),+               ("var",) <$> (args !? #var :: Maybe NDArrayHandle),+               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle),+               ("rescale_grad",) <$>+                 (args !? #rescale_grad :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mp_adamw_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_mp_adamw_update_upd ::+                     forall args . Fullfilled "_mp_adamw_update(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_mp_adamw_update(ndarray)" args -> IO ()+_mp_adamw_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("eta",) . showValue <$> (args !? #eta :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle),+               ("var",) <$> (args !? #var :: Maybe NDArrayHandle),+               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle),+               ("rescale_grad",) <$>+                 (args !? #rescale_grad :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mp_adamw_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_adamw_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),+        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float),+        '("wd", AttrOpt Float), '("eta", AttrReq Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle), '("mean", AttrOpt NDArrayHandle),+        '("var", AttrOpt NDArrayHandle),+        '("rescale_grad", AttrOpt NDArrayHandle)]++_adamw_update ::+              forall args . Fullfilled "_adamw_update(ndarray)" args =>+                ArgsHMap "_adamw_update(ndarray)" args -> IO [NDArrayHandle]+_adamw_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("eta",) . showValue <$> (args !? #eta :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle),+               ("var",) <$> (args !? #var :: Maybe NDArrayHandle),+               ("rescale_grad",) <$>+                 (args !? #rescale_grad :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_adamw_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_adamw_update_upd ::+                  forall args . Fullfilled "_adamw_update(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_adamw_update(ndarray)" args -> IO ()+_adamw_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("eta",) . showValue <$> (args !? #eta :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle),+               ("var",) <$> (args !? #var :: Maybe NDArrayHandle),+               ("rescale_grad",) <$>+                 (args !? #rescale_grad :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_adamw_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_quadratic(ndarray)" =+     '[ '("a", AttrOpt Float), '("b", AttrOpt Float),+        '("c", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_contrib_quadratic ::+                   forall args . Fullfilled "_contrib_quadratic(ndarray)" args =>+                     ArgsHMap "_contrib_quadratic(ndarray)" args -> IO [NDArrayHandle]+_contrib_quadratic args+  = let scalarArgs+          = catMaybes+              [("a",) . showValue <$> (args !? #a :: Maybe Float),+               ("b",) . showValue <$> (args !? #b :: Maybe Float),+               ("c",) . showValue <$> (args !? #c :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quadratic"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_quadratic_upd ::+                       forall args . Fullfilled "_contrib_quadratic(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_contrib_quadratic(ndarray)" args -> IO ()+_contrib_quadratic_upd outputs args+  = let scalarArgs+          = catMaybes+              [("a",) . showValue <$> (args !? #a :: Maybe Float),+               ("b",) . showValue <$> (args !? #b :: Maybe Float),+               ("c",) . showValue <$> (args !? #c :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quadratic"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_backward_quadratic(ndarray)"+     = '[]++_contrib_backward_quadratic ::+                            forall args .+                              Fullfilled "_contrib_backward_quadratic(ndarray)" args =>+                              ArgsHMap "_contrib_backward_quadratic(ndarray)" args ->+                                IO [NDArrayHandle]+_contrib_backward_quadratic args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_backward_quadratic"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_backward_quadratic_upd ::+                                forall args .+                                  Fullfilled "_contrib_backward_quadratic(ndarray)" args =>+                                  [NDArrayHandle] ->+                                    ArgsHMap "_contrib_backward_quadratic(ndarray)" args -> IO ()+_contrib_backward_quadratic_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_backward_quadratic"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_div_sqrt_dim(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_contrib_div_sqrt_dim ::+                      forall args . Fullfilled "_contrib_div_sqrt_dim(ndarray)" args =>+                        ArgsHMap "_contrib_div_sqrt_dim(ndarray)" args ->+                          IO [NDArrayHandle]+_contrib_div_sqrt_dim args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_div_sqrt_dim"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_div_sqrt_dim_upd ::+                          forall args . Fullfilled "_contrib_div_sqrt_dim(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_contrib_div_sqrt_dim(ndarray)" args -> IO ()+_contrib_div_sqrt_dim_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_div_sqrt_dim"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "all_finite(ndarray)" =+     '[ '("init_output", AttrOpt Bool),+        '("data", AttrOpt NDArrayHandle)]++all_finite ::+           forall args . Fullfilled "all_finite(ndarray)" args =>+             ArgsHMap "all_finite(ndarray)" args -> IO [NDArrayHandle]+all_finite args+  = let scalarArgs+          = catMaybes+              [("init_output",) . showValue <$>+                 (args !? #init_output :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "all_finite"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++all_finite_upd ::+               forall args . Fullfilled "all_finite(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "all_finite(ndarray)" args -> IO ()+all_finite_upd outputs args+  = let scalarArgs+          = catMaybes+              [("init_output",) . showValue <$>+                 (args !? #init_output :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "all_finite"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "multi_all_finite(ndarray)" =+     '[ '("num_arrays", AttrOpt Int), '("init_output", AttrOpt Bool),+        '("data", AttrOpt [NDArrayHandle])]++multi_all_finite ::+                 forall args . Fullfilled "multi_all_finite(ndarray)" args =>+                   ArgsHMap "multi_all_finite(ndarray)" args -> IO [NDArrayHandle]+multi_all_finite args+  = let scalarArgs+          = catMaybes+              [("num_arrays",) . showValue <$>+                 (args !? #num_arrays :: Maybe Int),+               ("init_output",) . showValue <$>+                 (args !? #init_output :: Maybe Bool)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "multi_all_finite"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++multi_all_finite_upd ::+                     forall args . Fullfilled "multi_all_finite(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "multi_all_finite(ndarray)" args -> IO ()+multi_all_finite_upd outputs args+  = let scalarArgs+          = catMaybes+              [("num_arrays",) . showValue <$>+                 (args !? #num_arrays :: Maybe Int),+               ("init_output",) . showValue <$>+                 (args !? #init_output :: Maybe Bool)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "multi_all_finite"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_index_array(ndarray)" =+     '[ '("axes", AttrOpt (Maybe [Int])),+        '("data", AttrOpt NDArrayHandle)]++_contrib_index_array ::+                     forall args . Fullfilled "_contrib_index_array(ndarray)" args =>+                       ArgsHMap "_contrib_index_array(ndarray)" args -> IO [NDArrayHandle]+_contrib_index_array args+  = let scalarArgs+          = catMaybes+              [("axes",) . showValue <$> (args !? #axes :: Maybe (Maybe [Int]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_index_array"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_index_array_upd ::+                         forall args . Fullfilled "_contrib_index_array(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_contrib_index_array(ndarray)" args -> IO ()+_contrib_index_array_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axes",) . showValue <$> (args !? #axes :: Maybe (Maybe [Int]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_index_array"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_index_copy(ndarray)" =+     '[ '("old_tensor", AttrOpt NDArrayHandle),+        '("index_vector", AttrOpt NDArrayHandle),+        '("new_tensor", AttrOpt NDArrayHandle)]++_contrib_index_copy ::+                    forall args . Fullfilled "_contrib_index_copy(ndarray)" args =>+                      ArgsHMap "_contrib_index_copy(ndarray)" args -> IO [NDArrayHandle]+_contrib_index_copy args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("old_tensor",) <$> (args !? #old_tensor :: Maybe NDArrayHandle),+               ("index_vector",) <$>+                 (args !? #index_vector :: Maybe NDArrayHandle),+               ("new_tensor",) <$> (args !? #new_tensor :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_index_copy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_index_copy_upd ::+                        forall args . Fullfilled "_contrib_index_copy(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_contrib_index_copy(ndarray)" args -> IO ()+_contrib_index_copy_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("old_tensor",) <$> (args !? #old_tensor :: Maybe NDArrayHandle),+               ("index_vector",) <$>+                 (args !? #index_vector :: Maybe NDArrayHandle),+               ("new_tensor",) <$> (args !? #new_tensor :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_index_copy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_backward_index_copy(ndarray)"+     = '[]++_contrib_backward_index_copy ::+                             forall args .+                               Fullfilled "_contrib_backward_index_copy(ndarray)" args =>+                               ArgsHMap "_contrib_backward_index_copy(ndarray)" args ->+                                 IO [NDArrayHandle]+_contrib_backward_index_copy args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_backward_index_copy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_backward_index_copy_upd ::+                                 forall args .+                                   Fullfilled "_contrib_backward_index_copy(ndarray)" args =>+                                   [NDArrayHandle] ->+                                     ArgsHMap "_contrib_backward_index_copy(ndarray)" args -> IO ()+_contrib_backward_index_copy_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_backward_index_copy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_ROIAlign(ndarray)" =+     '[ '("pooled_size", AttrReq [Int]),+        '("spatial_scale", AttrReq Float), '("sample_ratio", AttrOpt Int),+        '("position_sensitive", AttrOpt Bool),+        '("data", AttrOpt NDArrayHandle), '("rois", AttrOpt NDArrayHandle)]++_contrib_ROIAlign ::+                  forall args . Fullfilled "_contrib_ROIAlign(ndarray)" args =>+                    ArgsHMap "_contrib_ROIAlign(ndarray)" args -> IO [NDArrayHandle]+_contrib_ROIAlign args+  = let scalarArgs+          = catMaybes+              [("pooled_size",) . showValue <$>+                 (args !? #pooled_size :: Maybe [Int]),+               ("spatial_scale",) . showValue <$>+                 (args !? #spatial_scale :: Maybe Float),+               ("sample_ratio",) . showValue <$>+                 (args !? #sample_ratio :: Maybe Int),+               ("position_sensitive",) . showValue <$>+                 (args !? #position_sensitive :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_ROIAlign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_ROIAlign_upd ::+                      forall args . Fullfilled "_contrib_ROIAlign(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_contrib_ROIAlign(ndarray)" args -> IO ()+_contrib_ROIAlign_upd outputs args+  = let scalarArgs+          = catMaybes+              [("pooled_size",) . showValue <$>+                 (args !? #pooled_size :: Maybe [Int]),+               ("spatial_scale",) . showValue <$>+                 (args !? #spatial_scale :: Maybe Float),+               ("sample_ratio",) . showValue <$>+                 (args !? #sample_ratio :: Maybe Int),+               ("position_sensitive",) . showValue <$>+                 (args !? #position_sensitive :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_ROIAlign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_ROIAlign(ndarray)" = '[]++_backward_ROIAlign ::+                   forall args . Fullfilled "_backward_ROIAlign(ndarray)" args =>+                     ArgsHMap "_backward_ROIAlign(ndarray)" args -> IO [NDArrayHandle]+_backward_ROIAlign args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_ROIAlign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_ROIAlign_upd ::+                       forall args . Fullfilled "_backward_ROIAlign(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_backward_ROIAlign(ndarray)" args -> IO ()+_backward_ROIAlign_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_ROIAlign"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_box_nms(ndarray)" =+     '[ '("overlap_thresh", AttrOpt Float),+        '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int),+        '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int),+        '("id_index", AttrOpt Int), '("background_id", AttrOpt Int),+        '("force_suppress", AttrOpt Bool),+        '("in_format", AttrOpt (EnumType '["center", "corner"])),+        '("out_format", AttrOpt (EnumType '["center", "corner"])),+        '("data", AttrOpt NDArrayHandle)]++_contrib_box_nms ::+                 forall args . Fullfilled "_contrib_box_nms(ndarray)" args =>+                   ArgsHMap "_contrib_box_nms(ndarray)" args -> IO [NDArrayHandle]+_contrib_box_nms args+  = let scalarArgs+          = catMaybes+              [("overlap_thresh",) . showValue <$>+                 (args !? #overlap_thresh :: Maybe Float),+               ("valid_thresh",) . showValue <$>+                 (args !? #valid_thresh :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),+               ("coord_start",) . showValue <$>+                 (args !? #coord_start :: Maybe Int),+               ("score_index",) . showValue <$>+                 (args !? #score_index :: Maybe Int),+               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),+               ("background_id",) . showValue <$>+                 (args !? #background_id :: Maybe Int),+               ("force_suppress",) . showValue <$>+                 (args !? #force_suppress :: Maybe Bool),+               ("in_format",) . showValue <$>+                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),+               ("out_format",) . showValue <$>+                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_box_nms"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_box_nms_upd ::+                     forall args . Fullfilled "_contrib_box_nms(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_contrib_box_nms(ndarray)" args -> IO ()+_contrib_box_nms_upd outputs args+  = let scalarArgs+          = catMaybes+              [("overlap_thresh",) . showValue <$>+                 (args !? #overlap_thresh :: Maybe Float),+               ("valid_thresh",) . showValue <$>+                 (args !? #valid_thresh :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),+               ("coord_start",) . showValue <$>+                 (args !? #coord_start :: Maybe Int),+               ("score_index",) . showValue <$>+                 (args !? #score_index :: Maybe Int),+               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),+               ("background_id",) . showValue <$>+                 (args !? #background_id :: Maybe Int),+               ("force_suppress",) . showValue <$>+                 (args !? #force_suppress :: Maybe Bool),+               ("in_format",) . showValue <$>+                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),+               ("out_format",) . showValue <$>+                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_box_nms"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_contrib_box_nms(ndarray)" =+     '[ '("overlap_thresh", AttrOpt Float),+        '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int),+        '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int),+        '("id_index", AttrOpt Int), '("background_id", AttrOpt Int),+        '("force_suppress", AttrOpt Bool),+        '("in_format", AttrOpt (EnumType '["center", "corner"])),+        '("out_format", AttrOpt (EnumType '["center", "corner"]))]++_backward_contrib_box_nms ::+                          forall args .+                            Fullfilled "_backward_contrib_box_nms(ndarray)" args =>+                            ArgsHMap "_backward_contrib_box_nms(ndarray)" args ->+                              IO [NDArrayHandle]+_backward_contrib_box_nms args+  = let scalarArgs+          = catMaybes+              [("overlap_thresh",) . showValue <$>+                 (args !? #overlap_thresh :: Maybe Float),+               ("valid_thresh",) . showValue <$>+                 (args !? #valid_thresh :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),+               ("coord_start",) . showValue <$>+                 (args !? #coord_start :: Maybe Int),+               ("score_index",) . showValue <$>+                 (args !? #score_index :: Maybe Int),+               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),+               ("background_id",) . showValue <$>+                 (args !? #background_id :: Maybe Int),+               ("force_suppress",) . showValue <$>+                 (args !? #force_suppress :: Maybe Bool),+               ("in_format",) . showValue <$>+                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),+               ("out_format",) . showValue <$>+                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_box_nms"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_contrib_box_nms_upd ::+                              forall args .+                                Fullfilled "_backward_contrib_box_nms(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_backward_contrib_box_nms(ndarray)" args -> IO ()+_backward_contrib_box_nms_upd outputs args+  = let scalarArgs+          = catMaybes+              [("overlap_thresh",) . showValue <$>+                 (args !? #overlap_thresh :: Maybe Float),+               ("valid_thresh",) . showValue <$>+                 (args !? #valid_thresh :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),+               ("coord_start",) . showValue <$>+                 (args !? #coord_start :: Maybe Int),+               ("score_index",) . showValue <$>+                 (args !? #score_index :: Maybe Int),+               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),+               ("background_id",) . showValue <$>+                 (args !? #background_id :: Maybe Int),+               ("force_suppress",) . showValue <$>+                 (args !? #force_suppress :: Maybe Bool),+               ("in_format",) . showValue <$>+                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),+               ("out_format",) . showValue <$>+                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_box_nms"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_box_iou(ndarray)" =+     '[ '("format", AttrOpt (EnumType '["center", "corner"])),+        '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]++_contrib_box_iou ::+                 forall args . Fullfilled "_contrib_box_iou(ndarray)" args =>+                   ArgsHMap "_contrib_box_iou(ndarray)" args -> IO [NDArrayHandle]+_contrib_box_iou args+  = let scalarArgs+          = catMaybes+              [("format",) . showValue <$>+                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_box_iou"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_box_iou_upd ::+                     forall args . Fullfilled "_contrib_box_iou(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_contrib_box_iou(ndarray)" args -> IO ()+_contrib_box_iou_upd outputs args+  = let scalarArgs+          = catMaybes+              [("format",) . showValue <$>+                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_box_iou"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_contrib_box_iou(ndarray)" =+     '[ '("format", AttrOpt (EnumType '["center", "corner"]))]++_backward_contrib_box_iou ::+                          forall args .+                            Fullfilled "_backward_contrib_box_iou(ndarray)" args =>+                            ArgsHMap "_backward_contrib_box_iou(ndarray)" args ->+                              IO [NDArrayHandle]+_backward_contrib_box_iou args+  = let scalarArgs+          = catMaybes+              [("format",) . showValue <$>+                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_box_iou"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_contrib_box_iou_upd ::+                              forall args .+                                Fullfilled "_backward_contrib_box_iou(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_backward_contrib_box_iou(ndarray)" args -> IO ()+_backward_contrib_box_iou_upd outputs args+  = let scalarArgs+          = catMaybes+              [("format",) . showValue <$>+                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_box_iou"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_bipartite_matching(ndarray)"+     =+     '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float),+        '("topk", AttrOpt Int), '("data", AttrOpt NDArrayHandle)]++_contrib_bipartite_matching ::+                            forall args .+                              Fullfilled "_contrib_bipartite_matching(ndarray)" args =>+                              ArgsHMap "_contrib_bipartite_matching(ndarray)" args ->+                                IO [NDArrayHandle]+_contrib_bipartite_matching args+  = let scalarArgs+          = catMaybes+              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_bipartite_matching"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_bipartite_matching_upd ::+                                forall args .+                                  Fullfilled "_contrib_bipartite_matching(ndarray)" args =>+                                  [NDArrayHandle] ->+                                    ArgsHMap "_contrib_bipartite_matching(ndarray)" args -> IO ()+_contrib_bipartite_matching_upd outputs args+  = let scalarArgs+          = catMaybes+              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_bipartite_matching"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward_contrib_bipartite_matching(ndarray)" =+     '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float),+        '("topk", AttrOpt Int)]++_backward_contrib_bipartite_matching ::+                                     forall args .+                                       Fullfilled "_backward_contrib_bipartite_matching(ndarray)"+                                         args =>+                                       ArgsHMap "_backward_contrib_bipartite_matching(ndarray)" args+                                         -> IO [NDArrayHandle]+_backward_contrib_bipartite_matching args+  = let scalarArgs+          = catMaybes+              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_bipartite_matching"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_contrib_bipartite_matching_upd ::+                                         forall args .+                                           Fullfilled+                                             "_backward_contrib_bipartite_matching(ndarray)" args =>+                                           [NDArrayHandle] ->+                                             ArgsHMap+                                               "_backward_contrib_bipartite_matching(ndarray)"+                                               args+                                               -> IO ()+_backward_contrib_bipartite_matching_upd outputs args+  = let scalarArgs+          = catMaybes+              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_bipartite_matching"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_BilinearResize2D(ndarray)" =+     '[ '("height", AttrOpt Int), '("width", AttrOpt Int),+        '("scale_height", AttrOpt (Maybe Float)),+        '("scale_width", AttrOpt (Maybe Float)),+        '("mode",+          AttrOpt+            (EnumType+               '["like", "odd_scale", "size", "to_even_down", "to_even_up",+                 "to_odd_down", "to_odd_up"])),+        '("data", AttrOpt NDArrayHandle), '("like", AttrOpt NDArrayHandle)]++_contrib_BilinearResize2D ::+                          forall args .+                            Fullfilled "_contrib_BilinearResize2D(ndarray)" args =>+                            ArgsHMap "_contrib_BilinearResize2D(ndarray)" args ->+                              IO [NDArrayHandle]+_contrib_BilinearResize2D args+  = let scalarArgs+          = catMaybes+              [("height",) . showValue <$> (args !? #height :: Maybe Int),+               ("width",) . showValue <$> (args !? #width :: Maybe Int),+               ("scale_height",) . showValue <$>+                 (args !? #scale_height :: Maybe (Maybe Float)),+               ("scale_width",) . showValue <$>+                 (args !? #scale_width :: Maybe (Maybe Float)),+               ("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe+                      (EnumType+                         '["like", "odd_scale", "size", "to_even_down", "to_even_up",+                           "to_odd_down", "to_odd_up"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("like",) <$> (args !? #like :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_BilinearResize2D"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_BilinearResize2D_upd ::+                              forall args .+                                Fullfilled "_contrib_BilinearResize2D(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_contrib_BilinearResize2D(ndarray)" args -> IO ()+_contrib_BilinearResize2D_upd outputs args+  = let scalarArgs+          = catMaybes+              [("height",) . showValue <$> (args !? #height :: Maybe Int),+               ("width",) . showValue <$> (args !? #width :: Maybe Int),+               ("scale_height",) . showValue <$>+                 (args !? #scale_height :: Maybe (Maybe Float)),+               ("scale_width",) . showValue <$>+                 (args !? #scale_width :: Maybe (Maybe Float)),+               ("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe+                      (EnumType+                         '["like", "odd_scale", "size", "to_even_down", "to_even_up",+                           "to_odd_down", "to_odd_up"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("like",) <$> (args !? #like :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_BilinearResize2D"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward_contrib_BilinearResize2D(ndarray)" = '[]++_backward_contrib_BilinearResize2D ::+                                   forall args .+                                     Fullfilled "_backward_contrib_BilinearResize2D(ndarray)"+                                       args =>+                                     ArgsHMap "_backward_contrib_BilinearResize2D(ndarray)" args ->+                                       IO [NDArrayHandle]+_backward_contrib_BilinearResize2D args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_BilinearResize2D"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_contrib_BilinearResize2D_upd ::+                                       forall args .+                                         Fullfilled "_backward_contrib_BilinearResize2D(ndarray)"+                                           args =>+                                         [NDArrayHandle] ->+                                           ArgsHMap "_backward_contrib_BilinearResize2D(ndarray)"+                                             args+                                             -> IO ()+_backward_contrib_BilinearResize2D_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_BilinearResize2D"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_boolean_mask(ndarray)" =+     '[ '("axis", AttrOpt Int), '("data", AttrOpt NDArrayHandle),+        '("index", AttrOpt NDArrayHandle)]++_contrib_boolean_mask ::+                      forall args . Fullfilled "_contrib_boolean_mask(ndarray)" args =>+                        ArgsHMap "_contrib_boolean_mask(ndarray)" args ->+                          IO [NDArrayHandle]+_contrib_boolean_mask args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("index",) <$> (args !? #index :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_boolean_mask"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_boolean_mask_upd ::+                          forall args . Fullfilled "_contrib_boolean_mask(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_contrib_boolean_mask(ndarray)" args -> IO ()+_contrib_boolean_mask_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("index",) <$> (args !? #index :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_boolean_mask"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward_contrib_boolean_mask(ndarray)" =+     '[ '("axis", AttrOpt Int)]++_backward_contrib_boolean_mask ::+                               forall args .+                                 Fullfilled "_backward_contrib_boolean_mask(ndarray)" args =>+                                 ArgsHMap "_backward_contrib_boolean_mask(ndarray)" args ->+                                   IO [NDArrayHandle]+_backward_contrib_boolean_mask args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_boolean_mask"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_contrib_boolean_mask_upd ::+                                   forall args .+                                     Fullfilled "_backward_contrib_boolean_mask(ndarray)" args =>+                                     [NDArrayHandle] ->+                                       ArgsHMap "_backward_contrib_boolean_mask(ndarray)" args ->+                                         IO ()+_backward_contrib_boolean_mask_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_boolean_mask"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_SyncBatchNorm(ndarray)" =+     '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float),+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),+        '("output_mean_var", AttrOpt Bool), '("ndev", AttrOpt Int),+        '("key", AttrReq String), '("data", AttrOpt NDArrayHandle),+        '("gamma", AttrOpt NDArrayHandle),+        '("beta", AttrOpt NDArrayHandle),+        '("moving_mean", AttrOpt NDArrayHandle),+        '("moving_var", AttrOpt NDArrayHandle)]++_contrib_SyncBatchNorm ::+                       forall args . Fullfilled "_contrib_SyncBatchNorm(ndarray)" args =>+                         ArgsHMap "_contrib_SyncBatchNorm(ndarray)" args ->+                           IO [NDArrayHandle]+_contrib_SyncBatchNorm args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool),+               ("ndev",) . showValue <$> (args !? #ndev :: Maybe Int),+               ("key",) . showValue <$> (args !? #key :: Maybe String)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),+               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),+               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_SyncBatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_SyncBatchNorm_upd ::+                           forall args . Fullfilled "_contrib_SyncBatchNorm(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_contrib_SyncBatchNorm(ndarray)" args -> IO ()+_contrib_SyncBatchNorm_upd outputs args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool),+               ("ndev",) . showValue <$> (args !? #ndev :: Maybe Int),+               ("key",) . showValue <$> (args !? #key :: Maybe String)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),+               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),+               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_SyncBatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_contrib_AdaptiveAvgPooling2D(ndarray)" =+     '[ '("output_size", AttrOpt [Int]),+        '("data", AttrOpt NDArrayHandle)]++_contrib_AdaptiveAvgPooling2D ::+                              forall args .+                                Fullfilled "_contrib_AdaptiveAvgPooling2D(ndarray)" args =>+                                ArgsHMap "_contrib_AdaptiveAvgPooling2D(ndarray)" args ->+                                  IO [NDArrayHandle]+_contrib_AdaptiveAvgPooling2D args+  = let scalarArgs+          = catMaybes+              [("output_size",) . showValue <$>+                 (args !? #output_size :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_AdaptiveAvgPooling2D"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_AdaptiveAvgPooling2D_upd ::+                                  forall args .+                                    Fullfilled "_contrib_AdaptiveAvgPooling2D(ndarray)" args =>+                                    [NDArrayHandle] ->+                                      ArgsHMap "_contrib_AdaptiveAvgPooling2D(ndarray)" args ->+                                        IO ()+_contrib_AdaptiveAvgPooling2D_upd outputs args+  = let scalarArgs+          = catMaybes+              [("output_size",) . showValue <$>+                 (args !? #output_size :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_AdaptiveAvgPooling2D"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward_contrib_AdaptiveAvgPooling2D(ndarray)" =+     '[]++_backward_contrib_AdaptiveAvgPooling2D ::+                                       forall args .+                                         Fullfilled+                                           "_backward_contrib_AdaptiveAvgPooling2D(ndarray)" args =>+                                         ArgsHMap "_backward_contrib_AdaptiveAvgPooling2D(ndarray)"+                                           args+                                           -> IO [NDArrayHandle]+_backward_contrib_AdaptiveAvgPooling2D args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_AdaptiveAvgPooling2D"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_contrib_AdaptiveAvgPooling2D_upd ::+                                           forall args .+                                             Fullfilled+                                               "_backward_contrib_AdaptiveAvgPooling2D(ndarray)"+                                               args =>+                                             [NDArrayHandle] ->+                                               ArgsHMap+                                                 "_backward_contrib_AdaptiveAvgPooling2D(ndarray)"+                                                 args+                                                 -> IO ()+_backward_contrib_AdaptiveAvgPooling2D_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_AdaptiveAvgPooling2D"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_crop(ndarray)" =+     '[ '("x", AttrReq Int), '("y", AttrReq Int),+        '("width", AttrReq Int), '("height", AttrReq Int),+        '("data", AttrOpt NDArrayHandle)]++_image_crop ::+            forall args . Fullfilled "_image_crop(ndarray)" args =>+              ArgsHMap "_image_crop(ndarray)" args -> IO [NDArrayHandle]+_image_crop args+  = let scalarArgs+          = catMaybes+              [("x",) . showValue <$> (args !? #x :: Maybe Int),+               ("y",) . showValue <$> (args !? #y :: Maybe Int),+               ("width",) . showValue <$> (args !? #width :: Maybe Int),+               ("height",) . showValue <$> (args !? #height :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_crop"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_crop_upd ::+                forall args . Fullfilled "_image_crop(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_image_crop(ndarray)" args -> IO ()+_image_crop_upd outputs args+  = let scalarArgs+          = catMaybes+              [("x",) . showValue <$> (args !? #x :: Maybe Int),+               ("y",) . showValue <$> (args !? #y :: Maybe Int),+               ("width",) . showValue <$> (args !? #width :: Maybe Int),+               ("height",) . showValue <$> (args !? #height :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_crop"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_image_crop(ndarray)" = '[]++_backward_image_crop ::+                     forall args . Fullfilled "_backward_image_crop(ndarray)" args =>+                       ArgsHMap "_backward_image_crop(ndarray)" args -> IO [NDArrayHandle]+_backward_image_crop args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_image_crop"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_image_crop_upd ::+                         forall args . Fullfilled "_backward_image_crop(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_image_crop(ndarray)" args -> IO ()+_backward_image_crop_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_image_crop"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_to_tensor(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_image_to_tensor ::+                 forall args . Fullfilled "_image_to_tensor(ndarray)" args =>+                   ArgsHMap "_image_to_tensor(ndarray)" args -> IO [NDArrayHandle]+_image_to_tensor args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_to_tensor"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_to_tensor_upd ::+                     forall args . Fullfilled "_image_to_tensor(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_image_to_tensor(ndarray)" args -> IO ()+_image_to_tensor_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_to_tensor"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_normalize(ndarray)" =+     '[ '("mean", AttrOpt [Float]), '("std", AttrOpt [Float]),+        '("data", AttrOpt NDArrayHandle)]++_image_normalize ::+                 forall args . Fullfilled "_image_normalize(ndarray)" args =>+                   ArgsHMap "_image_normalize(ndarray)" args -> IO [NDArrayHandle]+_image_normalize args+  = let scalarArgs+          = catMaybes+              [("mean",) . showValue <$> (args !? #mean :: Maybe [Float]),+               ("std",) . showValue <$> (args !? #std :: Maybe [Float])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_normalize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_normalize_upd ::+                     forall args . Fullfilled "_image_normalize(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_image_normalize(ndarray)" args -> IO ()+_image_normalize_upd outputs args+  = let scalarArgs+          = catMaybes+              [("mean",) . showValue <$> (args !? #mean :: Maybe [Float]),+               ("std",) . showValue <$> (args !? #std :: Maybe [Float])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_normalize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_image_normalize(ndarray)" =+     '[]++_backward_image_normalize ::+                          forall args .+                            Fullfilled "_backward_image_normalize(ndarray)" args =>+                            ArgsHMap "_backward_image_normalize(ndarray)" args ->+                              IO [NDArrayHandle]+_backward_image_normalize args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_image_normalize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_image_normalize_upd ::+                              forall args .+                                Fullfilled "_backward_image_normalize(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_backward_image_normalize(ndarray)" args -> IO ()+_backward_image_normalize_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_image_normalize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_flip_left_right(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_image_flip_left_right ::+                       forall args . Fullfilled "_image_flip_left_right(ndarray)" args =>+                         ArgsHMap "_image_flip_left_right(ndarray)" args ->+                           IO [NDArrayHandle]+_image_flip_left_right args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_flip_left_right"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_flip_left_right_upd ::+                           forall args . Fullfilled "_image_flip_left_right(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_image_flip_left_right(ndarray)" args -> IO ()+_image_flip_left_right_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_flip_left_right"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_image_random_flip_left_right(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_image_random_flip_left_right ::+                              forall args .+                                Fullfilled "_image_random_flip_left_right(ndarray)" args =>+                                ArgsHMap "_image_random_flip_left_right(ndarray)" args ->+                                  IO [NDArrayHandle]+_image_random_flip_left_right args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_flip_left_right"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_random_flip_left_right_upd ::+                                  forall args .+                                    Fullfilled "_image_random_flip_left_right(ndarray)" args =>+                                    [NDArrayHandle] ->+                                      ArgsHMap "_image_random_flip_left_right(ndarray)" args ->+                                        IO ()+_image_random_flip_left_right_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_flip_left_right"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_flip_top_bottom(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_image_flip_top_bottom ::+                       forall args . Fullfilled "_image_flip_top_bottom(ndarray)" args =>+                         ArgsHMap "_image_flip_top_bottom(ndarray)" args ->+                           IO [NDArrayHandle]+_image_flip_top_bottom args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_flip_top_bottom"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_flip_top_bottom_upd ::+                           forall args . Fullfilled "_image_flip_top_bottom(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_image_flip_top_bottom(ndarray)" args -> IO ()+_image_flip_top_bottom_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_flip_top_bottom"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_image_random_flip_top_bottom(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_image_random_flip_top_bottom ::+                              forall args .+                                Fullfilled "_image_random_flip_top_bottom(ndarray)" args =>+                                ArgsHMap "_image_random_flip_top_bottom(ndarray)" args ->+                                  IO [NDArrayHandle]+_image_random_flip_top_bottom args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_flip_top_bottom"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_random_flip_top_bottom_upd ::+                                  forall args .+                                    Fullfilled "_image_random_flip_top_bottom(ndarray)" args =>+                                    [NDArrayHandle] ->+                                      ArgsHMap "_image_random_flip_top_bottom(ndarray)" args ->+                                        IO ()+_image_random_flip_top_bottom_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_flip_top_bottom"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_random_brightness(ndarray)" =+     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),+        '("data", AttrOpt NDArrayHandle)]++_image_random_brightness ::+                         forall args .+                           Fullfilled "_image_random_brightness(ndarray)" args =>+                           ArgsHMap "_image_random_brightness(ndarray)" args ->+                             IO [NDArrayHandle]+_image_random_brightness args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_brightness"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_random_brightness_upd ::+                             forall args .+                               Fullfilled "_image_random_brightness(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_image_random_brightness(ndarray)" args -> IO ()+_image_random_brightness_upd outputs args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_brightness"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_random_contrast(ndarray)" =+     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),+        '("data", AttrOpt NDArrayHandle)]++_image_random_contrast ::+                       forall args . Fullfilled "_image_random_contrast(ndarray)" args =>+                         ArgsHMap "_image_random_contrast(ndarray)" args ->+                           IO [NDArrayHandle]+_image_random_contrast args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_contrast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_random_contrast_upd ::+                           forall args . Fullfilled "_image_random_contrast(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_image_random_contrast(ndarray)" args -> IO ()+_image_random_contrast_upd outputs args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_contrast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_random_saturation(ndarray)" =+     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),+        '("data", AttrOpt NDArrayHandle)]++_image_random_saturation ::+                         forall args .+                           Fullfilled "_image_random_saturation(ndarray)" args =>+                           ArgsHMap "_image_random_saturation(ndarray)" args ->+                             IO [NDArrayHandle]+_image_random_saturation args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_saturation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_random_saturation_upd ::+                             forall args .+                               Fullfilled "_image_random_saturation(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_image_random_saturation(ndarray)" args -> IO ()+_image_random_saturation_upd outputs args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_saturation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_random_hue(ndarray)" =+     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),+        '("data", AttrOpt NDArrayHandle)]++_image_random_hue ::+                  forall args . Fullfilled "_image_random_hue(ndarray)" args =>+                    ArgsHMap "_image_random_hue(ndarray)" args -> IO [NDArrayHandle]+_image_random_hue args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_hue"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_random_hue_upd ::+                      forall args . Fullfilled "_image_random_hue(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_image_random_hue(ndarray)" args -> IO ()+_image_random_hue_upd outputs args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_hue"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_random_color_jitter(ndarray)" =+     '[ '("brightness", AttrReq Float), '("contrast", AttrReq Float),+        '("saturation", AttrReq Float), '("hue", AttrReq Float),+        '("data", AttrOpt NDArrayHandle)]++_image_random_color_jitter ::+                           forall args .+                             Fullfilled "_image_random_color_jitter(ndarray)" args =>+                             ArgsHMap "_image_random_color_jitter(ndarray)" args ->+                               IO [NDArrayHandle]+_image_random_color_jitter args+  = let scalarArgs+          = catMaybes+              [("brightness",) . showValue <$>+                 (args !? #brightness :: Maybe Float),+               ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float),+               ("saturation",) . showValue <$>+                 (args !? #saturation :: Maybe Float),+               ("hue",) . showValue <$> (args !? #hue :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_color_jitter"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_random_color_jitter_upd ::+                               forall args .+                                 Fullfilled "_image_random_color_jitter(ndarray)" args =>+                                 [NDArrayHandle] ->+                                   ArgsHMap "_image_random_color_jitter(ndarray)" args -> IO ()+_image_random_color_jitter_upd outputs args+  = let scalarArgs+          = catMaybes+              [("brightness",) . showValue <$>+                 (args !? #brightness :: Maybe Float),+               ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float),+               ("saturation",) . showValue <$>+                 (args !? #saturation :: Maybe Float),+               ("hue",) . showValue <$> (args !? #hue :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_color_jitter"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_adjust_lighting(ndarray)" =+     '[ '("alpha", AttrReq [Float]), '("data", AttrOpt NDArrayHandle)]++_image_adjust_lighting ::+                       forall args . Fullfilled "_image_adjust_lighting(ndarray)" args =>+                         ArgsHMap "_image_adjust_lighting(ndarray)" args ->+                           IO [NDArrayHandle]+_image_adjust_lighting args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe [Float])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_adjust_lighting"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_adjust_lighting_upd ::+                           forall args . Fullfilled "_image_adjust_lighting(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_image_adjust_lighting(ndarray)" args -> IO ()+_image_adjust_lighting_upd outputs args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe [Float])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_adjust_lighting"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_random_lighting(ndarray)" =+     '[ '("alpha_std", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]++_image_random_lighting ::+                       forall args . Fullfilled "_image_random_lighting(ndarray)" args =>+                         ArgsHMap "_image_random_lighting(ndarray)" args ->+                           IO [NDArrayHandle]+_image_random_lighting args+  = let scalarArgs+          = catMaybes+              [("alpha_std",) . showValue <$>+                 (args !? #alpha_std :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_lighting"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_random_lighting_upd ::+                           forall args . Fullfilled "_image_random_lighting(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_image_random_lighting(ndarray)" args -> IO ()+_image_random_lighting_upd outputs args+  = let scalarArgs+          = catMaybes+              [("alpha_std",) . showValue <$>+                 (args !? #alpha_std :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_lighting"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_image_resize(ndarray)" =+     '[ '("size", AttrOpt [Int]), '("keep_ratio", AttrOpt Bool),+        '("interp", AttrOpt Int), '("data", AttrOpt NDArrayHandle)]++_image_resize ::+              forall args . Fullfilled "_image_resize(ndarray)" args =>+                ArgsHMap "_image_resize(ndarray)" args -> IO [NDArrayHandle]+_image_resize args+  = let scalarArgs+          = catMaybes+              [("size",) . showValue <$> (args !? #size :: Maybe [Int]),+               ("keep_ratio",) . showValue <$>+                 (args !? #keep_ratio :: Maybe Bool),+               ("interp",) . showValue <$> (args !? #interp :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_resize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_image_resize_upd ::+                  forall args . Fullfilled "_image_resize(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_image_resize(ndarray)" args -> IO ()+_image_resize_upd outputs args+  = let scalarArgs+          = catMaybes+              [("size",) . showValue <$> (args !? #size :: Maybe [Int]),+               ("keep_ratio",) . showValue <$>+                 (args !? #keep_ratio :: Maybe Bool),+               ("interp",) . showValue <$> (args !? #interp :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_resize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "moments(ndarray)" =+     '[ '("axes", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("data", AttrOpt NDArrayHandle)]++moments ::+        forall args . Fullfilled "moments(ndarray)" args =>+          ArgsHMap "moments(ndarray)" args -> IO [NDArrayHandle]+moments args+  = let scalarArgs+          = catMaybes+              [("axes",) . showValue <$> (args !? #axes :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "moments"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++moments_upd ::+            forall args . Fullfilled "moments(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "moments(ndarray)" args -> IO ()+moments_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axes",) . showValue <$> (args !? #axes :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "moments"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_moments(ndarray)" = '[]++_backward_moments ::+                  forall args . Fullfilled "_backward_moments(ndarray)" args =>+                    ArgsHMap "_backward_moments(ndarray)" args -> IO [NDArrayHandle]+_backward_moments args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_moments"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_moments_upd ::+                      forall args . Fullfilled "_backward_moments(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_moments(ndarray)" args -> IO ()+_backward_moments_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_moments"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "softmax(ndarray)" =+     '[ '("axis", AttrOpt Int),+        '("temperature", AttrOpt (Maybe Double)),+        '("dtype",+          AttrOpt (Maybe (EnumType '["float16", "float32", "float64"]))),+        '("data", AttrOpt NDArrayHandle)]++softmax ::+        forall args . Fullfilled "softmax(ndarray)" args =>+          ArgsHMap "softmax(ndarray)" args -> IO [NDArrayHandle]+softmax args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("temperature",) . showValue <$>+                 (args !? #temperature :: Maybe (Maybe Double)),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (Maybe (EnumType '["float16", "float32", "float64"])))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++softmax_upd ::+            forall args . Fullfilled "softmax(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "softmax(ndarray)" args -> IO ()+softmax_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("temperature",) . showValue <$>+                 (args !? #temperature :: Maybe (Maybe Double)),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (Maybe (EnumType '["float16", "float32", "float64"])))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_softmax(ndarray)" =+     '[ '("args", AttrOpt [NDArrayHandle])]++_backward_softmax ::+                  forall args . Fullfilled "_backward_softmax(ndarray)" args =>+                    ArgsHMap "_backward_softmax(ndarray)" args -> IO [NDArrayHandle]+_backward_softmax args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "_backward_softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_softmax_upd ::+                      forall args . Fullfilled "_backward_softmax(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_softmax(ndarray)" args -> IO ()+_backward_softmax_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "_backward_softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "softmin(ndarray)" =+     '[ '("axis", AttrOpt Int),+        '("temperature", AttrOpt (Maybe Double)),+        '("dtype",+          AttrOpt (Maybe (EnumType '["float16", "float32", "float64"]))),+        '("data", AttrOpt NDArrayHandle)]++softmin ::+        forall args . Fullfilled "softmin(ndarray)" args =>+          ArgsHMap "softmin(ndarray)" args -> IO [NDArrayHandle]+softmin args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("temperature",) . showValue <$>+                 (args !? #temperature :: Maybe (Maybe Double)),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (Maybe (EnumType '["float16", "float32", "float64"])))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softmin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++softmin_upd ::+            forall args . Fullfilled "softmin(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "softmin(ndarray)" args -> IO ()+softmin_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("temperature",) . showValue <$>+                 (args !? #temperature :: Maybe (Maybe Double)),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (Maybe (EnumType '["float16", "float32", "float64"])))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softmin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_softmin(ndarray)" =+     '[ '("args", AttrOpt [NDArrayHandle])]++_backward_softmin ::+                  forall args . Fullfilled "_backward_softmin(ndarray)" args =>+                    ArgsHMap "_backward_softmin(ndarray)" args -> IO [NDArrayHandle]+_backward_softmin args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "_backward_softmin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_softmin_upd ::+                      forall args . Fullfilled "_backward_softmin(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_softmin(ndarray)" args -> IO ()+_backward_softmin_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "_backward_softmin"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "log_softmax(ndarray)" =+     '[ '("axis", AttrOpt Int),+        '("temperature", AttrOpt (Maybe Double)),+        '("dtype",+          AttrOpt (Maybe (EnumType '["float16", "float32", "float64"]))),+        '("data", AttrOpt NDArrayHandle)]++log_softmax ::+            forall args . Fullfilled "log_softmax(ndarray)" args =>+              ArgsHMap "log_softmax(ndarray)" args -> IO [NDArrayHandle]+log_softmax args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("temperature",) . showValue <$>+                 (args !? #temperature :: Maybe (Maybe Double)),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (Maybe (EnumType '["float16", "float32", "float64"])))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log_softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++log_softmax_upd ::+                forall args . Fullfilled "log_softmax(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "log_softmax(ndarray)" args -> IO ()+log_softmax_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("temperature",) . showValue <$>+                 (args !? #temperature :: Maybe (Maybe Double)),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (Maybe (EnumType '["float16", "float32", "float64"])))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log_softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_log_softmax(ndarray)" =+     '[ '("args", AttrOpt [NDArrayHandle])]++_backward_log_softmax ::+                      forall args . Fullfilled "_backward_log_softmax(ndarray)" args =>+                        ArgsHMap "_backward_log_softmax(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_log_softmax args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "_backward_log_softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_log_softmax_upd ::+                          forall args . Fullfilled "_backward_log_softmax(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_log_softmax(ndarray)" args -> IO ()+_backward_log_softmax_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "_backward_log_softmax"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Pooling(ndarray)" =+     '[ '("kernel", AttrOpt [Int]),+        '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])),+        '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool),+        '("pooling_convention",+          AttrOpt (EnumType '["full", "same", "valid"])),+        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("p_value", AttrOpt (Maybe Int)),+        '("count_include_pad", AttrOpt (Maybe Bool)),+        '("layout",+          AttrOpt+            (Maybe+               (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"]))),+        '("data", AttrOpt NDArrayHandle)]++_Pooling ::+         forall args . Fullfilled "_Pooling(ndarray)" args =>+           ArgsHMap "_Pooling(ndarray)" args -> IO [NDArrayHandle]+_Pooling args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("pool_type",) . showValue <$>+                 (args !? #pool_type ::+                    Maybe (EnumType '["avg", "lp", "max", "sum"])),+               ("global_pool",) . showValue <$>+                 (args !? #global_pool :: Maybe Bool),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("pooling_convention",) . showValue <$>+                 (args !? #pooling_convention ::+                    Maybe (EnumType '["full", "same", "valid"])),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("p_value",) . showValue <$>+                 (args !? #p_value :: Maybe (Maybe Int)),+               ("count_include_pad",) . showValue <$>+                 (args !? #count_include_pad :: Maybe (Maybe Bool)),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe+                         (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"])))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Pooling_upd ::+             forall args . Fullfilled "_Pooling(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "_Pooling(ndarray)" args -> IO ()+_Pooling_upd outputs args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("pool_type",) . showValue <$>+                 (args !? #pool_type ::+                    Maybe (EnumType '["avg", "lp", "max", "sum"])),+               ("global_pool",) . showValue <$>+                 (args !? #global_pool :: Maybe Bool),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("pooling_convention",) . showValue <$>+                 (args !? #pooling_convention ::+                    Maybe (EnumType '["full", "same", "valid"])),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("p_value",) . showValue <$>+                 (args !? #p_value :: Maybe (Maybe Int)),+               ("count_include_pad",) . showValue <$>+                 (args !? #count_include_pad :: Maybe (Maybe Bool)),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe+                         (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"])))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Pooling(ndarray)" = '[]++_backward_Pooling ::+                  forall args . Fullfilled "_backward_Pooling(ndarray)" args =>+                    ArgsHMap "_backward_Pooling(ndarray)" args -> IO [NDArrayHandle]+_backward_Pooling args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Pooling_upd ::+                      forall args . Fullfilled "_backward_Pooling(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_Pooling(ndarray)" args -> IO ()+_backward_Pooling_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Deconvolution(ndarray)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("adj", AttrOpt [Int]), '("target_shape", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("cudnn_tune",+          AttrOpt+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+        '("cudnn_off", AttrOpt Bool),+        '("layout",+          AttrOpt+            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),+        '("data", AttrOpt NDArrayHandle),+        '("weight", AttrOpt NDArrayHandle),+        '("bias", AttrOpt NDArrayHandle)]++_Deconvolution ::+               forall args . Fullfilled "_Deconvolution(ndarray)" args =>+                 ArgsHMap "_Deconvolution(ndarray)" args -> IO [NDArrayHandle]+_Deconvolution args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Deconvolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Deconvolution_upd ::+                   forall args . Fullfilled "_Deconvolution(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_Deconvolution(ndarray)" args -> IO ()+_Deconvolution_upd outputs args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Deconvolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Deconvolution(ndarray)" =+     '[]++_backward_Deconvolution ::+                        forall args . Fullfilled "_backward_Deconvolution(ndarray)" args =>+                          ArgsHMap "_backward_Deconvolution(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_Deconvolution args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Deconvolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Deconvolution_upd ::+                            forall args . Fullfilled "_backward_Deconvolution(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_Deconvolution(ndarray)" args -> IO ()+_backward_Deconvolution_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Deconvolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Activation(ndarray)" =+     '[ '("act_type",+          AttrReq+            (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"])),+        '("data", AttrOpt NDArrayHandle)]++_Activation ::+            forall args . Fullfilled "_Activation(ndarray)" args =>+              ArgsHMap "_Activation(ndarray)" args -> IO [NDArrayHandle]+_Activation args+  = let scalarArgs+          = catMaybes+              [("act_type",) . showValue <$>+                 (args !? #act_type ::+                    Maybe+                      (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Activation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Activation_upd ::+                forall args . Fullfilled "_Activation(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_Activation(ndarray)" args -> IO ()+_Activation_upd outputs args+  = let scalarArgs+          = catMaybes+              [("act_type",) . showValue <$>+                 (args !? #act_type ::+                    Maybe+                      (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Activation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Activation(ndarray)" = '[]++_backward_Activation ::+                     forall args . Fullfilled "_backward_Activation(ndarray)" args =>+                       ArgsHMap "_backward_Activation(ndarray)" args -> IO [NDArrayHandle]+_backward_Activation args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Activation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Activation_upd ::+                         forall args . Fullfilled "_backward_Activation(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_Activation(ndarray)" args -> IO ()+_backward_Activation_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Activation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_UpSampling(ndarray)" =+     '[ '("scale", AttrReq Int), '("num_filter", AttrOpt Int),+        '("sample_type", AttrReq (EnumType '["bilinear", "nearest"])),+        '("multi_input_mode", AttrOpt (EnumType '["concat", "sum"])),+        '("num_args", AttrReq Int), '("workspace", AttrOpt Int),+        '("data", AttrOpt [NDArrayHandle])]++_UpSampling ::+            forall args . Fullfilled "_UpSampling(ndarray)" args =>+              ArgsHMap "_UpSampling(ndarray)" args -> IO [NDArrayHandle]+_UpSampling args+  = let scalarArgs+          = catMaybes+              [("scale",) . showValue <$> (args !? #scale :: Maybe Int),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("sample_type",) . showValue <$>+                 (args !? #sample_type ::+                    Maybe (EnumType '["bilinear", "nearest"])),+               ("multi_input_mode",) . showValue <$>+                 (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])),+               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "UpSampling"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        Nothing+         return listndarr++_UpSampling_upd ::+                forall args . Fullfilled "_UpSampling(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_UpSampling(ndarray)" args -> IO ()+_UpSampling_upd outputs args+  = let scalarArgs+          = catMaybes+              [("scale",) . showValue <$> (args !? #scale :: Maybe Int),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("sample_type",) . showValue <$>+                 (args !? #sample_type ::+                    Maybe (EnumType '["bilinear", "nearest"])),+               ("multi_input_mode",) . showValue <$>+                 (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])),+               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "UpSampling"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        (Just outputs)+         return ()++type instance ParameterList "_backward_UpSampling(ndarray)" = '[]++_backward_UpSampling ::+                     forall args . Fullfilled "_backward_UpSampling(ndarray)" args =>+                       ArgsHMap "_backward_UpSampling(ndarray)" args -> IO [NDArrayHandle]+_backward_UpSampling args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_UpSampling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_UpSampling_upd ::+                         forall args . Fullfilled "_backward_UpSampling(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_UpSampling(ndarray)" args -> IO ()+_backward_UpSampling_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_UpSampling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_BatchNorm(ndarray)" =+     '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float),+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),+        '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int),+        '("cudnn_off", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),+        '("gamma", AttrOpt NDArrayHandle),+        '("beta", AttrOpt NDArrayHandle),+        '("moving_mean", AttrOpt NDArrayHandle),+        '("moving_var", AttrOpt NDArrayHandle)]++_BatchNorm ::+           forall args . Fullfilled "_BatchNorm(ndarray)" args =>+             ArgsHMap "_BatchNorm(ndarray)" args -> IO [NDArrayHandle]+_BatchNorm args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),+               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),+               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_BatchNorm_upd ::+               forall args . Fullfilled "_BatchNorm(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "_BatchNorm(ndarray)" args -> IO ()+_BatchNorm_upd outputs args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),+               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),+               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_BatchNorm(ndarray)" = '[]++_backward_BatchNorm ::+                    forall args . Fullfilled "_backward_BatchNorm(ndarray)" args =>+                      ArgsHMap "_backward_BatchNorm(ndarray)" args -> IO [NDArrayHandle]+_backward_BatchNorm args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_BatchNorm_upd ::+                        forall args . Fullfilled "_backward_BatchNorm(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_backward_BatchNorm(ndarray)" args -> IO ()+_backward_BatchNorm_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_CTCLoss(ndarray)" =+     '[ '("use_data_lengths", AttrOpt Bool),+        '("use_label_lengths", AttrOpt Bool),+        '("blank_label", AttrOpt (EnumType '["first", "last"])),+        '("data", AttrOpt NDArrayHandle),+        '("label", AttrOpt NDArrayHandle),+        '("data_lengths", AttrOpt NDArrayHandle),+        '("label_lengths", AttrOpt NDArrayHandle)]++_CTCLoss ::+         forall args . Fullfilled "_CTCLoss(ndarray)" args =>+           ArgsHMap "_CTCLoss(ndarray)" args -> IO [NDArrayHandle]+_CTCLoss args+  = let scalarArgs+          = catMaybes+              [("use_data_lengths",) . showValue <$>+                 (args !? #use_data_lengths :: Maybe Bool),+               ("use_label_lengths",) . showValue <$>+                 (args !? #use_label_lengths :: Maybe Bool),+               ("blank_label",) . showValue <$>+                 (args !? #blank_label :: Maybe (EnumType '["first", "last"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle),+               ("data_lengths",) <$>+                 (args !? #data_lengths :: Maybe NDArrayHandle),+               ("label_lengths",) <$>+                 (args !? #label_lengths :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "CTCLoss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_CTCLoss_upd ::+             forall args . Fullfilled "_CTCLoss(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "_CTCLoss(ndarray)" args -> IO ()+_CTCLoss_upd outputs args+  = let scalarArgs+          = catMaybes+              [("use_data_lengths",) . showValue <$>+                 (args !? #use_data_lengths :: Maybe Bool),+               ("use_label_lengths",) . showValue <$>+                 (args !? #use_label_lengths :: Maybe Bool),+               ("blank_label",) . showValue <$>+                 (args !? #blank_label :: Maybe (EnumType '["first", "last"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle),+               ("data_lengths",) <$>+                 (args !? #data_lengths :: Maybe NDArrayHandle),+               ("label_lengths",) <$>+                 (args !? #label_lengths :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "CTCLoss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_ctc_loss(ndarray)" = '[]++_backward_ctc_loss ::+                   forall args . Fullfilled "_backward_ctc_loss(ndarray)" args =>+                     ArgsHMap "_backward_ctc_loss(ndarray)" args -> IO [NDArrayHandle]+_backward_ctc_loss args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_ctc_loss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_ctc_loss_upd ::+                       forall args . Fullfilled "_backward_ctc_loss(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_backward_ctc_loss(ndarray)" args -> IO ()+_backward_ctc_loss_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_ctc_loss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_FullyConnected(ndarray)" =+     '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool),+        '("flatten", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),+        '("weight", AttrOpt NDArrayHandle),+        '("bias", AttrOpt NDArrayHandle)]++_FullyConnected ::+                forall args . Fullfilled "_FullyConnected(ndarray)" args =>+                  ArgsHMap "_FullyConnected(ndarray)" args -> IO [NDArrayHandle]+_FullyConnected args+  = let scalarArgs+          = catMaybes+              [("num_hidden",) . showValue <$>+                 (args !? #num_hidden :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "FullyConnected"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_FullyConnected_upd ::+                    forall args . Fullfilled "_FullyConnected(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_FullyConnected(ndarray)" args -> IO ()+_FullyConnected_upd outputs args+  = let scalarArgs+          = catMaybes+              [("num_hidden",) . showValue <$>+                 (args !? #num_hidden :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "FullyConnected"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_FullyConnected(ndarray)" =+     '[]++_backward_FullyConnected ::+                         forall args .+                           Fullfilled "_backward_FullyConnected(ndarray)" args =>+                           ArgsHMap "_backward_FullyConnected(ndarray)" args ->+                             IO [NDArrayHandle]+_backward_FullyConnected args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_FullyConnected"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_FullyConnected_upd ::+                             forall args .+                               Fullfilled "_backward_FullyConnected(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_backward_FullyConnected(ndarray)" args -> IO ()+_backward_FullyConnected_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_FullyConnected"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Convolution(ndarray)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("cudnn_tune",+          AttrOpt+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+        '("cudnn_off", AttrOpt Bool),+        '("layout",+          AttrOpt+            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),+        '("data", AttrOpt NDArrayHandle),+        '("weight", AttrOpt NDArrayHandle),+        '("bias", AttrOpt NDArrayHandle)]++_Convolution ::+             forall args . Fullfilled "_Convolution(ndarray)" args =>+               ArgsHMap "_Convolution(ndarray)" args -> IO [NDArrayHandle]+_Convolution args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Convolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Convolution_upd ::+                 forall args . Fullfilled "_Convolution(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_Convolution(ndarray)" args -> IO ()+_Convolution_upd outputs args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Convolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Convolution(ndarray)" = '[]++_backward_Convolution ::+                      forall args . Fullfilled "_backward_Convolution(ndarray)" args =>+                        ArgsHMap "_backward_Convolution(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_Convolution args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Convolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Convolution_upd ::+                          forall args . Fullfilled "_backward_Convolution(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_Convolution(ndarray)" args -> IO ()+_backward_Convolution_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Convolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_LayerNorm(ndarray)" =+     '[ '("axis", AttrOpt Int), '("eps", AttrOpt Float),+        '("output_mean_var", AttrOpt Bool),+        '("data", AttrOpt NDArrayHandle),+        '("gamma", AttrOpt NDArrayHandle),+        '("beta", AttrOpt NDArrayHandle)]++_LayerNorm ::+           forall args . Fullfilled "_LayerNorm(ndarray)" args =>+             ArgsHMap "_LayerNorm(ndarray)" args -> IO [NDArrayHandle]+_LayerNorm args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LayerNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_LayerNorm_upd ::+               forall args . Fullfilled "_LayerNorm(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "_LayerNorm(ndarray)" args -> IO ()+_LayerNorm_upd outputs args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LayerNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_LayerNorm(ndarray)" = '[]++_backward_LayerNorm ::+                    forall args . Fullfilled "_backward_LayerNorm(ndarray)" args =>+                      ArgsHMap "_backward_LayerNorm(ndarray)" args -> IO [NDArrayHandle]+_backward_LayerNorm args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LayerNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_LayerNorm_upd ::+                        forall args . Fullfilled "_backward_LayerNorm(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_backward_LayerNorm(ndarray)" args -> IO ()+_backward_LayerNorm_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LayerNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Concat(ndarray)" =+     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),+        '("data", AttrOpt [NDArrayHandle])]++_Concat ::+        forall args . Fullfilled "_Concat(ndarray)" args =>+          ArgsHMap "_Concat(ndarray)" args -> IO [NDArrayHandle]+_Concat args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "Concat"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        Nothing+         return listndarr++_Concat_upd ::+            forall args . Fullfilled "_Concat(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "_Concat(ndarray)" args -> IO ()+_Concat_upd outputs args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "Concat"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Concat(ndarray)" = '[]++_backward_Concat ::+                 forall args . Fullfilled "_backward_Concat(ndarray)" args =>+                   ArgsHMap "_backward_Concat(ndarray)" args -> IO [NDArrayHandle]+_backward_Concat args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Concat"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Concat_upd ::+                     forall args . Fullfilled "_backward_Concat(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_backward_Concat(ndarray)" args -> IO ()+_backward_Concat_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Concat"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_rnn_param_concat(ndarray)" =+     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),+        '("data", AttrOpt [NDArrayHandle])]++_rnn_param_concat ::+                  forall args . Fullfilled "_rnn_param_concat(ndarray)" args =>+                    ArgsHMap "_rnn_param_concat(ndarray)" args -> IO [NDArrayHandle]+_rnn_param_concat args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "_rnn_param_concat"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        Nothing+         return listndarr++_rnn_param_concat_upd ::+                      forall args . Fullfilled "_rnn_param_concat(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_rnn_param_concat(ndarray)" args -> IO ()+_rnn_param_concat_upd outputs args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "_rnn_param_concat"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        (Just outputs)+         return ()++type instance ParameterList "_SoftmaxActivation(ndarray)" =+     '[ '("mode", AttrOpt (EnumType '["channel", "instance"])),+        '("data", AttrOpt NDArrayHandle)]++_SoftmaxActivation ::+                   forall args . Fullfilled "_SoftmaxActivation(ndarray)" args =>+                     ArgsHMap "_SoftmaxActivation(ndarray)" args -> IO [NDArrayHandle]+_SoftmaxActivation args+  = let scalarArgs+          = catMaybes+              [("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["channel", "instance"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SoftmaxActivation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_SoftmaxActivation_upd ::+                       forall args . Fullfilled "_SoftmaxActivation(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_SoftmaxActivation(ndarray)" args -> IO ()+_SoftmaxActivation_upd outputs args+  = let scalarArgs+          = catMaybes+              [("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["channel", "instance"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SoftmaxActivation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SoftmaxActivation(ndarray)"+     = '[]++_backward_SoftmaxActivation ::+                            forall args .+                              Fullfilled "_backward_SoftmaxActivation(ndarray)" args =>+                              ArgsHMap "_backward_SoftmaxActivation(ndarray)" args ->+                                IO [NDArrayHandle]+_backward_SoftmaxActivation args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SoftmaxActivation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SoftmaxActivation_upd ::+                                forall args .+                                  Fullfilled "_backward_SoftmaxActivation(ndarray)" args =>+                                  [NDArrayHandle] ->+                                    ArgsHMap "_backward_SoftmaxActivation(ndarray)" args -> IO ()+_backward_SoftmaxActivation_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SoftmaxActivation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_LRN(ndarray)" =+     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),+        '("knorm", AttrOpt Float), '("nsize", AttrReq Int),+        '("data", AttrOpt NDArrayHandle)]++_LRN ::+     forall args . Fullfilled "_LRN(ndarray)" args =>+       ArgsHMap "_LRN(ndarray)" args -> IO [NDArrayHandle]+_LRN args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float),+               ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LRN"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_LRN_upd ::+         forall args . Fullfilled "_LRN(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "_LRN(ndarray)" args -> IO ()+_LRN_upd outputs args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float),+               ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LRN"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_LRN(ndarray)" = '[]++_backward_LRN ::+              forall args . Fullfilled "_backward_LRN(ndarray)" args =>+                ArgsHMap "_backward_LRN(ndarray)" args -> IO [NDArrayHandle]+_backward_LRN args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LRN"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_LRN_upd ::+                  forall args . Fullfilled "_backward_LRN(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_LRN(ndarray)" args -> IO ()+_backward_LRN_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LRN"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Dropout(ndarray)" =+     '[ '("p", AttrOpt Float),+        '("mode", AttrOpt (EnumType '["always", "training"])),+        '("axes", AttrOpt [Int]), '("cudnn_off", AttrOpt (Maybe Bool)),+        '("data", AttrOpt NDArrayHandle)]++_Dropout ::+         forall args . Fullfilled "_Dropout(ndarray)" args =>+           ArgsHMap "_Dropout(ndarray)" args -> IO [NDArrayHandle]+_Dropout args+  = let scalarArgs+          = catMaybes+              [("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["always", "training"])),+               ("axes",) . showValue <$> (args !? #axes :: Maybe [Int]),+               ("cudnn_off",) . showValue <$>+                 (args !? #cudnn_off :: Maybe (Maybe Bool))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Dropout"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Dropout_upd ::+             forall args . Fullfilled "_Dropout(ndarray)" args =>+               [NDArrayHandle] -> ArgsHMap "_Dropout(ndarray)" args -> IO ()+_Dropout_upd outputs args+  = let scalarArgs+          = catMaybes+              [("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["always", "training"])),+               ("axes",) . showValue <$> (args !? #axes :: Maybe [Int]),+               ("cudnn_off",) . showValue <$>+                 (args !? #cudnn_off :: Maybe (Maybe Bool))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Dropout"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Dropout(ndarray)" = '[]++_backward_Dropout ::+                  forall args . Fullfilled "_backward_Dropout(ndarray)" args =>+                    ArgsHMap "_backward_Dropout(ndarray)" args -> IO [NDArrayHandle]+_backward_Dropout args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Dropout"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Dropout_upd ::+                      forall args . Fullfilled "_backward_Dropout(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_Dropout(ndarray)" args -> IO ()+_backward_Dropout_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Dropout"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_contrib_quantized_elemwise_add(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle),+        '("lhs_min", AttrOpt NDArrayHandle),+        '("lhs_max", AttrOpt NDArrayHandle),+        '("rhs_min", AttrOpt NDArrayHandle),+        '("rhs_max", AttrOpt NDArrayHandle)]++_contrib_quantized_elemwise_add ::+                                forall args .+                                  Fullfilled "_contrib_quantized_elemwise_add(ndarray)" args =>+                                  ArgsHMap "_contrib_quantized_elemwise_add(ndarray)" args ->+                                    IO [NDArrayHandle]+_contrib_quantized_elemwise_add args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle),+               ("lhs_min",) <$> (args !? #lhs_min :: Maybe NDArrayHandle),+               ("lhs_max",) <$> (args !? #lhs_max :: Maybe NDArrayHandle),+               ("rhs_min",) <$> (args !? #rhs_min :: Maybe NDArrayHandle),+               ("rhs_max",) <$> (args !? #rhs_max :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_elemwise_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_quantized_elemwise_add_upd ::+                                    forall args .+                                      Fullfilled "_contrib_quantized_elemwise_add(ndarray)" args =>+                                      [NDArrayHandle] ->+                                        ArgsHMap "_contrib_quantized_elemwise_add(ndarray)" args ->+                                          IO ()+_contrib_quantized_elemwise_add_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle),+               ("lhs_min",) <$> (args !? #lhs_min :: Maybe NDArrayHandle),+               ("lhs_max",) <$> (args !? #lhs_max :: Maybe NDArrayHandle),+               ("rhs_min",) <$> (args !? #rhs_min :: Maybe NDArrayHandle),+               ("rhs_max",) <$> (args !? #rhs_max :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_elemwise_add"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_dequantize(ndarray)" =+     '[ '("out_type", AttrOpt (EnumType '["float32"])),+        '("data", AttrOpt NDArrayHandle),+        '("min_range", AttrOpt NDArrayHandle),+        '("max_range", AttrOpt NDArrayHandle)]++_contrib_dequantize ::+                    forall args . Fullfilled "_contrib_dequantize(ndarray)" args =>+                      ArgsHMap "_contrib_dequantize(ndarray)" args -> IO [NDArrayHandle]+_contrib_dequantize args+  = let scalarArgs+          = catMaybes+              [("out_type",) . showValue <$>+                 (args !? #out_type :: Maybe (EnumType '["float32"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),+               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_dequantize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_dequantize_upd ::+                        forall args . Fullfilled "_contrib_dequantize(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_contrib_dequantize(ndarray)" args -> IO ()+_contrib_dequantize_upd outputs args+  = let scalarArgs+          = catMaybes+              [("out_type",) . showValue <$>+                 (args !? #out_type :: Maybe (EnumType '["float32"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),+               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_dequantize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_quantized_flatten(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle),+        '("min_data", AttrOpt NDArrayHandle),+        '("max_data", AttrOpt NDArrayHandle)]++_contrib_quantized_flatten ::+                           forall args .+                             Fullfilled "_contrib_quantized_flatten(ndarray)" args =>+                             ArgsHMap "_contrib_quantized_flatten(ndarray)" args ->+                               IO [NDArrayHandle]+_contrib_quantized_flatten args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_flatten"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_quantized_flatten_upd ::+                               forall args .+                                 Fullfilled "_contrib_quantized_flatten(ndarray)" args =>+                                 [NDArrayHandle] ->+                                   ArgsHMap "_contrib_quantized_flatten(ndarray)" args -> IO ()+_contrib_quantized_flatten_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_flatten"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_quantized_conv(ndarray)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("cudnn_tune",+          AttrOpt+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+        '("cudnn_off", AttrOpt Bool),+        '("layout",+          AttrOpt+            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),+        '("data", AttrOpt NDArrayHandle),+        '("weight", AttrOpt NDArrayHandle),+        '("bias", AttrOpt NDArrayHandle),+        '("min_data", AttrOpt NDArrayHandle),+        '("max_data", AttrOpt NDArrayHandle),+        '("min_weight", AttrOpt NDArrayHandle),+        '("max_weight", AttrOpt NDArrayHandle),+        '("min_bias", AttrOpt NDArrayHandle),+        '("max_bias", AttrOpt NDArrayHandle)]++_contrib_quantized_conv ::+                        forall args . Fullfilled "_contrib_quantized_conv(ndarray)" args =>+                          ArgsHMap "_contrib_quantized_conv(ndarray)" args ->+                            IO [NDArrayHandle]+_contrib_quantized_conv args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle),+               ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle),+               ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle),+               ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle),+               ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_conv"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_quantized_conv_upd ::+                            forall args . Fullfilled "_contrib_quantized_conv(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_contrib_quantized_conv(ndarray)" args -> IO ()+_contrib_quantized_conv_upd outputs args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle),+               ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle),+               ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle),+               ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle),+               ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_conv"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_contrib_quantized_fully_connected(ndarray)" =+     '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool),+        '("flatten", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),+        '("weight", AttrOpt NDArrayHandle),+        '("bias", AttrOpt NDArrayHandle),+        '("min_data", AttrOpt NDArrayHandle),+        '("max_data", AttrOpt NDArrayHandle),+        '("min_weight", AttrOpt NDArrayHandle),+        '("max_weight", AttrOpt NDArrayHandle),+        '("min_bias", AttrOpt NDArrayHandle),+        '("max_bias", AttrOpt NDArrayHandle)]++_contrib_quantized_fully_connected ::+                                   forall args .+                                     Fullfilled "_contrib_quantized_fully_connected(ndarray)"+                                       args =>+                                     ArgsHMap "_contrib_quantized_fully_connected(ndarray)" args ->+                                       IO [NDArrayHandle]+_contrib_quantized_fully_connected args+  = let scalarArgs+          = catMaybes+              [("num_hidden",) . showValue <$>+                 (args !? #num_hidden :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle),+               ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle),+               ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle),+               ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle),+               ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_fully_connected"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_quantized_fully_connected_upd ::+                                       forall args .+                                         Fullfilled "_contrib_quantized_fully_connected(ndarray)"+                                           args =>+                                         [NDArrayHandle] ->+                                           ArgsHMap "_contrib_quantized_fully_connected(ndarray)"+                                             args+                                             -> IO ()+_contrib_quantized_fully_connected_upd outputs args+  = let scalarArgs+          = catMaybes+              [("num_hidden",) . showValue <$>+                 (args !? #num_hidden :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle),+               ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle),+               ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle),+               ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle),+               ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_fully_connected"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_quantized_pooling(ndarray)" =+     '[ '("kernel", AttrOpt [Int]),+        '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])),+        '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool),+        '("pooling_convention",+          AttrOpt (EnumType '["full", "same", "valid"])),+        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("p_value", AttrOpt (Maybe Int)),+        '("count_include_pad", AttrOpt (Maybe Bool)),+        '("layout",+          AttrOpt+            (Maybe+               (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"]))),+        '("data", AttrOpt NDArrayHandle),+        '("min_data", AttrOpt NDArrayHandle),+        '("max_data", AttrOpt NDArrayHandle)]++_contrib_quantized_pooling ::+                           forall args .+                             Fullfilled "_contrib_quantized_pooling(ndarray)" args =>+                             ArgsHMap "_contrib_quantized_pooling(ndarray)" args ->+                               IO [NDArrayHandle]+_contrib_quantized_pooling args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("pool_type",) . showValue <$>+                 (args !? #pool_type ::+                    Maybe (EnumType '["avg", "lp", "max", "sum"])),+               ("global_pool",) . showValue <$>+                 (args !? #global_pool :: Maybe Bool),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("pooling_convention",) . showValue <$>+                 (args !? #pooling_convention ::+                    Maybe (EnumType '["full", "same", "valid"])),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("p_value",) . showValue <$>+                 (args !? #p_value :: Maybe (Maybe Int)),+               ("count_include_pad",) . showValue <$>+                 (args !? #count_include_pad :: Maybe (Maybe Bool)),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe+                         (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_pooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_quantized_pooling_upd ::+                               forall args .+                                 Fullfilled "_contrib_quantized_pooling(ndarray)" args =>+                                 [NDArrayHandle] ->+                                   ArgsHMap "_contrib_quantized_pooling(ndarray)" args -> IO ()+_contrib_quantized_pooling_upd outputs args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("pool_type",) . showValue <$>+                 (args !? #pool_type ::+                    Maybe (EnumType '["avg", "lp", "max", "sum"])),+               ("global_pool",) . showValue <$>+                 (args !? #global_pool :: Maybe Bool),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("pooling_convention",) . showValue <$>+                 (args !? #pooling_convention ::+                    Maybe (EnumType '["full", "same", "valid"])),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("p_value",) . showValue <$>+                 (args !? #p_value :: Maybe (Maybe Int)),+               ("count_include_pad",) . showValue <$>+                 (args !? #count_include_pad :: Maybe (Maybe Bool)),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe+                         (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_pooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_quantize_v2(ndarray)" =+     '[ '("out_type", AttrOpt (EnumType '["auto", "int8", "uint8"])),+        '("min_calib_range", AttrOpt (Maybe Float)),+        '("max_calib_range", AttrOpt (Maybe Float)),+        '("data", AttrOpt NDArrayHandle)]++_contrib_quantize_v2 ::+                     forall args . Fullfilled "_contrib_quantize_v2(ndarray)" args =>+                       ArgsHMap "_contrib_quantize_v2(ndarray)" args -> IO [NDArrayHandle]+_contrib_quantize_v2 args+  = let scalarArgs+          = catMaybes+              [("out_type",) . showValue <$>+                 (args !? #out_type :: Maybe (EnumType '["auto", "int8", "uint8"])),+               ("min_calib_range",) . showValue <$>+                 (args !? #min_calib_range :: Maybe (Maybe Float)),+               ("max_calib_range",) . showValue <$>+                 (args !? #max_calib_range :: Maybe (Maybe Float))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantize_v2"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_quantize_v2_upd ::+                         forall args . Fullfilled "_contrib_quantize_v2(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_contrib_quantize_v2(ndarray)" args -> IO ()+_contrib_quantize_v2_upd outputs args+  = let scalarArgs+          = catMaybes+              [("out_type",) . showValue <$>+                 (args !? #out_type :: Maybe (EnumType '["auto", "int8", "uint8"])),+               ("min_calib_range",) . showValue <$>+                 (args !? #min_calib_range :: Maybe (Maybe Float)),+               ("max_calib_range",) . showValue <$>+                 (args !? #max_calib_range :: Maybe (Maybe Float))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantize_v2"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_quantized_concat(ndarray)" =+     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),+        '("data", AttrOpt [NDArrayHandle])]++_contrib_quantized_concat ::+                          forall args .+                            Fullfilled "_contrib_quantized_concat(ndarray)" args =>+                            ArgsHMap "_contrib_quantized_concat(ndarray)" args ->+                              IO [NDArrayHandle]+_contrib_quantized_concat args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "_contrib_quantized_concat"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        Nothing+         return listndarr++_contrib_quantized_concat_upd ::+                              forall args .+                                Fullfilled "_contrib_quantized_concat(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_contrib_quantized_concat(ndarray)" args -> IO ()+_contrib_quantized_concat_upd outputs args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "_contrib_quantized_concat"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_requantize(ndarray)" =+     '[ '("out_type", AttrOpt (EnumType '["auto", "int8", "uint8"])),+        '("min_calib_range", AttrOpt (Maybe Float)),+        '("max_calib_range", AttrOpt (Maybe Float)),+        '("data", AttrOpt NDArrayHandle),+        '("min_range", AttrOpt NDArrayHandle),+        '("max_range", AttrOpt NDArrayHandle)]++_contrib_requantize ::+                    forall args . Fullfilled "_contrib_requantize(ndarray)" args =>+                      ArgsHMap "_contrib_requantize(ndarray)" args -> IO [NDArrayHandle]+_contrib_requantize args+  = let scalarArgs+          = catMaybes+              [("out_type",) . showValue <$>+                 (args !? #out_type :: Maybe (EnumType '["auto", "int8", "uint8"])),+               ("min_calib_range",) . showValue <$>+                 (args !? #min_calib_range :: Maybe (Maybe Float)),+               ("max_calib_range",) . showValue <$>+                 (args !? #max_calib_range :: Maybe (Maybe Float))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),+               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_requantize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_requantize_upd ::+                        forall args . Fullfilled "_contrib_requantize(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_contrib_requantize(ndarray)" args -> IO ()+_contrib_requantize_upd outputs args+  = let scalarArgs+          = catMaybes+              [("out_type",) . showValue <$>+                 (args !? #out_type :: Maybe (EnumType '["auto", "int8", "uint8"])),+               ("min_calib_range",) . showValue <$>+                 (args !? #min_calib_range :: Maybe (Maybe Float)),+               ("max_calib_range",) . showValue <$>+                 (args !? #max_calib_range :: Maybe (Maybe Float))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),+               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_requantize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_quantized_act(ndarray)" =+     '[ '("act_type",+          AttrReq+            (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"])),+        '("data", AttrOpt NDArrayHandle),+        '("min_data", AttrOpt NDArrayHandle),+        '("max_data", AttrOpt NDArrayHandle)]++_contrib_quantized_act ::+                       forall args . Fullfilled "_contrib_quantized_act(ndarray)" args =>+                         ArgsHMap "_contrib_quantized_act(ndarray)" args ->+                           IO [NDArrayHandle]+_contrib_quantized_act args+  = let scalarArgs+          = catMaybes+              [("act_type",) . showValue <$>+                 (args !? #act_type ::+                    Maybe+                      (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_act"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_quantized_act_upd ::+                           forall args . Fullfilled "_contrib_quantized_act(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_contrib_quantized_act(ndarray)" args -> IO ()+_contrib_quantized_act_upd outputs args+  = let scalarArgs+          = catMaybes+              [("act_type",) . showValue <$>+                 (args !? #act_type ::+                    Maybe+                      (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_act"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_quantize(ndarray)" =+     '[ '("out_type", AttrOpt (EnumType '["int8", "uint8"])),+        '("data", AttrOpt NDArrayHandle),+        '("min_range", AttrOpt NDArrayHandle),+        '("max_range", AttrOpt NDArrayHandle)]++_contrib_quantize ::+                  forall args . Fullfilled "_contrib_quantize(ndarray)" args =>+                    ArgsHMap "_contrib_quantize(ndarray)" args -> IO [NDArrayHandle]+_contrib_quantize args+  = let scalarArgs+          = catMaybes+              [("out_type",) . showValue <$>+                 (args !? #out_type :: Maybe (EnumType '["int8", "uint8"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),+               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_quantize_upd ::+                      forall args . Fullfilled "_contrib_quantize(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_contrib_quantize(ndarray)" args -> IO ()+_contrib_quantize_upd outputs args+  = let scalarArgs+          = catMaybes+              [("out_type",) . showValue <$>+                 (args !? #out_type :: Maybe (EnumType '["int8", "uint8"]))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),+               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_cvimdecode(ndarray)" =+     '[ '("flag", AttrOpt Int), '("to_rgb", AttrOpt Bool),+        '("buf", AttrOpt NDArrayHandle)]++_cvimdecode ::+            forall args . Fullfilled "_cvimdecode(ndarray)" args =>+              ArgsHMap "_cvimdecode(ndarray)" args -> IO [NDArrayHandle]+_cvimdecode args+  = let scalarArgs+          = catMaybes+              [("flag",) . showValue <$> (args !? #flag :: Maybe Int),+               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]+        tensorArgs+          = catMaybes [("buf",) <$> (args !? #buf :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_cvimdecode"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_cvimdecode_upd ::+                forall args . Fullfilled "_cvimdecode(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_cvimdecode(ndarray)" args -> IO ()+_cvimdecode_upd outputs args+  = let scalarArgs+          = catMaybes+              [("flag",) . showValue <$> (args !? #flag :: Maybe Int),+               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]+        tensorArgs+          = catMaybes [("buf",) <$> (args !? #buf :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_cvimdecode"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_cvimread(ndarray)" =+     '[ '("filename", AttrReq String), '("flag", AttrOpt Int),+        '("to_rgb", AttrOpt Bool)]++_cvimread ::+          forall args . Fullfilled "_cvimread(ndarray)" args =>+            ArgsHMap "_cvimread(ndarray)" args -> IO [NDArrayHandle]+_cvimread args+  = let scalarArgs+          = catMaybes+              [("filename",) . showValue <$> (args !? #filename :: Maybe String),+               ("flag",) . showValue <$> (args !? #flag :: Maybe Int),+               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_cvimread"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_cvimread_upd ::+              forall args . Fullfilled "_cvimread(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "_cvimread(ndarray)" args -> IO ()+_cvimread_upd outputs args+  = let scalarArgs+          = catMaybes+              [("filename",) . showValue <$> (args !? #filename :: Maybe String),+               ("flag",) . showValue <$> (args !? #flag :: Maybe Int),+               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_cvimread"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_cvimresize(ndarray)" =+     '[ '("w", AttrReq Int), '("h", AttrReq Int),+        '("interp", AttrOpt Int), '("src", AttrOpt NDArrayHandle)]++_cvimresize ::+            forall args . Fullfilled "_cvimresize(ndarray)" args =>+              ArgsHMap "_cvimresize(ndarray)" args -> IO [NDArrayHandle]+_cvimresize args+  = let scalarArgs+          = catMaybes+              [("w",) . showValue <$> (args !? #w :: Maybe Int),+               ("h",) . showValue <$> (args !? #h :: Maybe Int),+               ("interp",) . showValue <$> (args !? #interp :: Maybe Int)]+        tensorArgs+          = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_cvimresize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_cvimresize_upd ::+                forall args . Fullfilled "_cvimresize(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_cvimresize(ndarray)" args -> IO ()+_cvimresize_upd outputs args+  = let scalarArgs+          = catMaybes+              [("w",) . showValue <$> (args !? #w :: Maybe Int),+               ("h",) . showValue <$> (args !? #h :: Maybe Int),+               ("interp",) . showValue <$> (args !? #interp :: Maybe Int)]+        tensorArgs+          = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_cvimresize"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_cvcopyMakeBorder(ndarray)" =+     '[ '("top", AttrReq Int), '("bot", AttrReq Int),+        '("left", AttrReq Int), '("right", AttrReq Int),+        '("type", AttrOpt Int), '("value", AttrOpt Double),+        '("values", AttrOpt [Double]), '("src", AttrOpt NDArrayHandle)]++_cvcopyMakeBorder ::+                  forall args . Fullfilled "_cvcopyMakeBorder(ndarray)" args =>+                    ArgsHMap "_cvcopyMakeBorder(ndarray)" args -> IO [NDArrayHandle]+_cvcopyMakeBorder args+  = let scalarArgs+          = catMaybes+              [("top",) . showValue <$> (args !? #top :: Maybe Int),+               ("bot",) . showValue <$> (args !? #bot :: Maybe Int),+               ("left",) . showValue <$> (args !? #left :: Maybe Int),+               ("right",) . showValue <$> (args !? #right :: Maybe Int),+               ("type",) . showValue <$> (args !? #type :: Maybe Int),+               ("value",) . showValue <$> (args !? #value :: Maybe Double),+               ("values",) . showValue <$> (args !? #values :: Maybe [Double])]+        tensorArgs+          = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_cvcopyMakeBorder"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_cvcopyMakeBorder_upd ::+                      forall args . Fullfilled "_cvcopyMakeBorder(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_cvcopyMakeBorder(ndarray)" args -> IO ()+_cvcopyMakeBorder_upd outputs args+  = let scalarArgs+          = catMaybes+              [("top",) . showValue <$> (args !? #top :: Maybe Int),+               ("bot",) . showValue <$> (args !? #bot :: Maybe Int),+               ("left",) . showValue <$> (args !? #left :: Maybe Int),+               ("right",) . showValue <$> (args !? #right :: Maybe Int),+               ("type",) . showValue <$> (args !? #type :: Maybe Int),+               ("value",) . showValue <$> (args !? #value :: Maybe Double),+               ("values",) . showValue <$> (args !? #values :: Maybe [Double])]+        tensorArgs+          = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_cvcopyMakeBorder"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_NoGradient(ndarray)" = '[]++_NoGradient ::+            forall args . Fullfilled "_NoGradient(ndarray)" args =>+              ArgsHMap "_NoGradient(ndarray)" args -> IO [NDArrayHandle]+_NoGradient args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_NoGradient"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_NoGradient_upd ::+                forall args . Fullfilled "_NoGradient(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_NoGradient(ndarray)" args -> IO ()+_NoGradient_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_NoGradient"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_CachedOp(ndarray)" =+     '[ '("data", AttrOpt [NDArrayHandle])]++_CachedOp ::+          forall args . Fullfilled "_CachedOp(ndarray)" args =>+            ArgsHMap "_CachedOp(ndarray)" args -> IO [NDArrayHandle]+_CachedOp args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "_CachedOp"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_CachedOp_upd ::+              forall args . Fullfilled "_CachedOp(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "_CachedOp(ndarray)" args -> IO ()+_CachedOp_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "_CachedOp"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_CachedOp(ndarray)" = '[]++_backward_CachedOp ::+                   forall args . Fullfilled "_backward_CachedOp(ndarray)" args =>+                     ArgsHMap "_backward_CachedOp(ndarray)" args -> IO [NDArrayHandle]+_backward_CachedOp args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_CachedOp"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_CachedOp_upd ::+                       forall args . Fullfilled "_backward_CachedOp(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_backward_CachedOp(ndarray)" args -> IO ()+_backward_CachedOp_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_CachedOp"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_copyto(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle)]++_copyto ::+        forall args . Fullfilled "_copyto(ndarray)" args =>+          ArgsHMap "_copyto(ndarray)" args -> IO [NDArrayHandle]+_copyto args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_copyto"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_copyto_upd ::+            forall args . Fullfilled "_copyto(ndarray)" args =>+              [NDArrayHandle] -> ArgsHMap "_copyto(ndarray)" args -> IO ()+_copyto_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_copyto"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "softmax_cross_entropy(ndarray)" =+     '[ '("data", AttrOpt NDArrayHandle),+        '("label", AttrOpt NDArrayHandle)]++softmax_cross_entropy ::+                      forall args . Fullfilled "softmax_cross_entropy(ndarray)" args =>+                        ArgsHMap "softmax_cross_entropy(ndarray)" args ->+                          IO [NDArrayHandle]+softmax_cross_entropy args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softmax_cross_entropy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++softmax_cross_entropy_upd ::+                          forall args . Fullfilled "softmax_cross_entropy(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "softmax_cross_entropy(ndarray)" args -> IO ()+softmax_cross_entropy_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softmax_cross_entropy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward_softmax_cross_entropy(ndarray)" = '[]++_backward_softmax_cross_entropy ::+                                forall args .+                                  Fullfilled "_backward_softmax_cross_entropy(ndarray)" args =>+                                  ArgsHMap "_backward_softmax_cross_entropy(ndarray)" args ->+                                    IO [NDArrayHandle]+_backward_softmax_cross_entropy args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_softmax_cross_entropy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_softmax_cross_entropy_upd ::+                                    forall args .+                                      Fullfilled "_backward_softmax_cross_entropy(ndarray)" args =>+                                      [NDArrayHandle] ->+                                        ArgsHMap "_backward_softmax_cross_entropy(ndarray)" args ->+                                          IO ()+_backward_softmax_cross_entropy_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_softmax_cross_entropy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_foreach(ndarray)" = '[]++_backward_foreach ::+                  forall args . Fullfilled "_backward_foreach(ndarray)" args =>+                    ArgsHMap "_backward_foreach(ndarray)" args -> IO [NDArrayHandle]+_backward_foreach args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_foreach"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_foreach_upd ::+                      forall args . Fullfilled "_backward_foreach(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward_foreach(ndarray)" args -> IO ()+_backward_foreach_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_foreach"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_while_loop(ndarray)" = '[]++_backward_while_loop ::+                     forall args . Fullfilled "_backward_while_loop(ndarray)" args =>+                       ArgsHMap "_backward_while_loop(ndarray)" args -> IO [NDArrayHandle]+_backward_while_loop args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_while_loop"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_while_loop_upd ::+                         forall args . Fullfilled "_backward_while_loop(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_while_loop(ndarray)" args -> IO ()+_backward_while_loop_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_while_loop"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_cond(ndarray)" = '[]++_backward_cond ::+               forall args . Fullfilled "_backward_cond(ndarray)" args =>+                 ArgsHMap "_backward_cond(ndarray)" args -> IO [NDArrayHandle]+_backward_cond args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cond"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_cond_upd ::+                   forall args . Fullfilled "_backward_cond(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_cond(ndarray)" args -> IO ()+_backward_cond_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cond"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_SoftmaxOutput(ndarray)" =+     '[ '("grad_scale", AttrOpt Float),+        '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool),+        '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool),+        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),+        '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle),+        '("label", AttrOpt NDArrayHandle)]++_SoftmaxOutput ::+               forall args . Fullfilled "_SoftmaxOutput(ndarray)" args =>+                 ArgsHMap "_SoftmaxOutput(ndarray)" args -> IO [NDArrayHandle]+_SoftmaxOutput args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float),+               ("ignore_label",) . showValue <$>+                 (args !? #ignore_label :: Maybe Float),+               ("multi_output",) . showValue <$>+                 (args !? #multi_output :: Maybe Bool),+               ("use_ignore",) . showValue <$>+                 (args !? #use_ignore :: Maybe Bool),+               ("preserve_shape",) . showValue <$>+                 (args !? #preserve_shape :: Maybe Bool),+               ("normalization",) . showValue <$>+                 (args !? #normalization ::+                    Maybe (EnumType '["batch", "null", "valid"])),+               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),+               ("smooth_alpha",) . showValue <$>+                 (args !? #smooth_alpha :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SoftmaxOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_SoftmaxOutput_upd ::+                   forall args . Fullfilled "_SoftmaxOutput(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_SoftmaxOutput(ndarray)" args -> IO ()+_SoftmaxOutput_upd outputs args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float),+               ("ignore_label",) . showValue <$>+                 (args !? #ignore_label :: Maybe Float),+               ("multi_output",) . showValue <$>+                 (args !? #multi_output :: Maybe Bool),+               ("use_ignore",) . showValue <$>+                 (args !? #use_ignore :: Maybe Bool),+               ("preserve_shape",) . showValue <$>+                 (args !? #preserve_shape :: Maybe Bool),+               ("normalization",) . showValue <$>+                 (args !? #normalization ::+                    Maybe (EnumType '["batch", "null", "valid"])),+               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),+               ("smooth_alpha",) . showValue <$>+                 (args !? #smooth_alpha :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SoftmaxOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SoftmaxOutput(ndarray)" =+     '[]++_backward_SoftmaxOutput ::+                        forall args . Fullfilled "_backward_SoftmaxOutput(ndarray)" args =>+                          ArgsHMap "_backward_SoftmaxOutput(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_SoftmaxOutput args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SoftmaxOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SoftmaxOutput_upd ::+                            forall args . Fullfilled "_backward_SoftmaxOutput(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_SoftmaxOutput(ndarray)" args -> IO ()+_backward_SoftmaxOutput_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SoftmaxOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_LeakyReLU(ndarray)" =+     '[ '("act_type",+          AttrOpt+            (EnumType '["elu", "gelu", "leaky", "prelu", "rrelu", "selu"])),+        '("slope", AttrOpt Float), '("lower_bound", AttrOpt Float),+        '("upper_bound", AttrOpt Float), '("data", AttrOpt NDArrayHandle),+        '("gamma", AttrOpt NDArrayHandle)]++_LeakyReLU ::+           forall args . Fullfilled "_LeakyReLU(ndarray)" args =>+             ArgsHMap "_LeakyReLU(ndarray)" args -> IO [NDArrayHandle]+_LeakyReLU args+  = let scalarArgs+          = catMaybes+              [("act_type",) . showValue <$>+                 (args !? #act_type ::+                    Maybe+                      (EnumType '["elu", "gelu", "leaky", "prelu", "rrelu", "selu"])),+               ("slope",) . showValue <$> (args !? #slope :: Maybe Float),+               ("lower_bound",) . showValue <$>+                 (args !? #lower_bound :: Maybe Float),+               ("upper_bound",) . showValue <$>+                 (args !? #upper_bound :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LeakyReLU"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_LeakyReLU_upd ::+               forall args . Fullfilled "_LeakyReLU(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "_LeakyReLU(ndarray)" args -> IO ()+_LeakyReLU_upd outputs args+  = let scalarArgs+          = catMaybes+              [("act_type",) . showValue <$>+                 (args !? #act_type ::+                    Maybe+                      (EnumType '["elu", "gelu", "leaky", "prelu", "rrelu", "selu"])),+               ("slope",) . showValue <$> (args !? #slope :: Maybe Float),+               ("lower_bound",) . showValue <$>+                 (args !? #lower_bound :: Maybe Float),+               ("upper_bound",) . showValue <$>+                 (args !? #upper_bound :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LeakyReLU"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_SwapAxis(ndarray)" =+     '[ '("dim1", AttrOpt Int), '("dim2", AttrOpt Int),+        '("data", AttrOpt NDArrayHandle)]++_SwapAxis ::+          forall args . Fullfilled "_SwapAxis(ndarray)" args =>+            ArgsHMap "_SwapAxis(ndarray)" args -> IO [NDArrayHandle]+_SwapAxis args+  = let scalarArgs+          = catMaybes+              [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int),+               ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SwapAxis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_SwapAxis_upd ::+              forall args . Fullfilled "_SwapAxis(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "_SwapAxis(ndarray)" args -> IO ()+_SwapAxis_upd outputs args+  = let scalarArgs+          = catMaybes+              [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int),+               ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SwapAxis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_IdentityAttachKLSparseReg(ndarray)" =+     '[ '("sparseness_target", AttrOpt Float),+        '("penalty", AttrOpt Float), '("momentum", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle)]++_IdentityAttachKLSparseReg ::+                           forall args .+                             Fullfilled "_IdentityAttachKLSparseReg(ndarray)" args =>+                             ArgsHMap "_IdentityAttachKLSparseReg(ndarray)" args ->+                               IO [NDArrayHandle]+_IdentityAttachKLSparseReg args+  = let scalarArgs+          = catMaybes+              [("sparseness_target",) . showValue <$>+                 (args !? #sparseness_target :: Maybe Float),+               ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "IdentityAttachKLSparseReg"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_IdentityAttachKLSparseReg_upd ::+                               forall args .+                                 Fullfilled "_IdentityAttachKLSparseReg(ndarray)" args =>+                                 [NDArrayHandle] ->+                                   ArgsHMap "_IdentityAttachKLSparseReg(ndarray)" args -> IO ()+_IdentityAttachKLSparseReg_upd outputs args+  = let scalarArgs+          = catMaybes+              [("sparseness_target",) . showValue <$>+                 (args !? #sparseness_target :: Maybe Float),+               ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "IdentityAttachKLSparseReg"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_SliceChannel(ndarray)" =+     '[ '("num_outputs", AttrReq Int), '("axis", AttrOpt Int),+        '("squeeze_axis", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]++_SliceChannel ::+              forall args . Fullfilled "_SliceChannel(ndarray)" args =>+                ArgsHMap "_SliceChannel(ndarray)" args -> IO [NDArrayHandle]+_SliceChannel args+  = let scalarArgs+          = catMaybes+              [("num_outputs",) . showValue <$>+                 (args !? #num_outputs :: Maybe Int),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("squeeze_axis",) . showValue <$>+                 (args !? #squeeze_axis :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SliceChannel"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_SliceChannel_upd ::+                  forall args . Fullfilled "_SliceChannel(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_SliceChannel(ndarray)" args -> IO ()+_SliceChannel_upd outputs args+  = let scalarArgs+          = catMaybes+              [("num_outputs",) . showValue <$>+                 (args !? #num_outputs :: Maybe Int),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("squeeze_axis",) . showValue <$>+                 (args !? #squeeze_axis :: Maybe Bool)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SliceChannel"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_RNN(ndarray)" =+     '[ '("state_size", AttrReq Int), '("num_layers", AttrReq Int),+        '("bidirectional", AttrOpt Bool),+        '("mode",+          AttrReq (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),+        '("p", AttrOpt Float), '("state_outputs", AttrOpt Bool),+        '("projection_size", AttrOpt (Maybe Int)),+        '("lstm_state_clip_min", AttrOpt (Maybe Double)),+        '("lstm_state_clip_max", AttrOpt (Maybe Double)),+        '("lstm_state_clip_nan", AttrOpt Bool),+        '("use_sequence_length", AttrOpt Bool),+        '("data", AttrOpt NDArrayHandle),+        '("parameters", AttrOpt NDArrayHandle),+        '("state", AttrOpt NDArrayHandle),+        '("state_cell", AttrOpt NDArrayHandle),+        '("sequence_length", AttrOpt NDArrayHandle)]++_RNN ::+     forall args . Fullfilled "_RNN(ndarray)" args =>+       ArgsHMap "_RNN(ndarray)" args -> IO [NDArrayHandle]+_RNN args+  = let scalarArgs+          = catMaybes+              [("state_size",) . showValue <$>+                 (args !? #state_size :: Maybe Int),+               ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int),+               ("bidirectional",) . showValue <$>+                 (args !? #bidirectional :: Maybe Bool),+               ("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),+               ("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("state_outputs",) . showValue <$>+                 (args !? #state_outputs :: Maybe Bool),+               ("projection_size",) . showValue <$>+                 (args !? #projection_size :: Maybe (Maybe Int)),+               ("lstm_state_clip_min",) . showValue <$>+                 (args !? #lstm_state_clip_min :: Maybe (Maybe Double)),+               ("lstm_state_clip_max",) . showValue <$>+                 (args !? #lstm_state_clip_max :: Maybe (Maybe Double)),+               ("lstm_state_clip_nan",) . showValue <$>+                 (args !? #lstm_state_clip_nan :: Maybe Bool),+               ("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("parameters",) <$> (args !? #parameters :: Maybe NDArrayHandle),+               ("state",) <$> (args !? #state :: Maybe NDArrayHandle),+               ("state_cell",) <$> (args !? #state_cell :: Maybe NDArrayHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "RNN"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_RNN_upd ::+         forall args . Fullfilled "_RNN(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "_RNN(ndarray)" args -> IO ()+_RNN_upd outputs args+  = let scalarArgs+          = catMaybes+              [("state_size",) . showValue <$>+                 (args !? #state_size :: Maybe Int),+               ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int),+               ("bidirectional",) . showValue <$>+                 (args !? #bidirectional :: Maybe Bool),+               ("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),+               ("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("state_outputs",) . showValue <$>+                 (args !? #state_outputs :: Maybe Bool),+               ("projection_size",) . showValue <$>+                 (args !? #projection_size :: Maybe (Maybe Int)),+               ("lstm_state_clip_min",) . showValue <$>+                 (args !? #lstm_state_clip_min :: Maybe (Maybe Double)),+               ("lstm_state_clip_max",) . showValue <$>+                 (args !? #lstm_state_clip_max :: Maybe (Maybe Double)),+               ("lstm_state_clip_nan",) . showValue <$>+                 (args !? #lstm_state_clip_nan :: Maybe Bool),+               ("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("parameters",) <$> (args !? #parameters :: Maybe NDArrayHandle),+               ("state",) <$> (args !? #state :: Maybe NDArrayHandle),+               ("state_cell",) <$> (args !? #state_cell :: Maybe NDArrayHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "RNN"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_RNN(ndarray)" = '[]++_backward_RNN ::+              forall args . Fullfilled "_backward_RNN(ndarray)" args =>+                ArgsHMap "_backward_RNN(ndarray)" args -> IO [NDArrayHandle]+_backward_RNN args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_RNN"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_RNN_upd ::+                  forall args . Fullfilled "_backward_RNN(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_RNN(ndarray)" args -> IO ()+_backward_RNN_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_RNN"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Pad(ndarray)" =+     '[ '("mode", AttrReq (EnumType '["constant", "edge", "reflect"])),+        '("pad_width", AttrReq [Int]), '("constant_value", AttrOpt Double),+        '("data", AttrOpt NDArrayHandle)]++_Pad ::+     forall args . Fullfilled "_Pad(ndarray)" args =>+       ArgsHMap "_Pad(ndarray)" args -> IO [NDArrayHandle]+_Pad args+  = let scalarArgs+          = catMaybes+              [("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["constant", "edge", "reflect"])),+               ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]),+               ("constant_value",) . showValue <$>+                 (args !? #constant_value :: Maybe Double)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pad"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Pad_upd ::+         forall args . Fullfilled "_Pad(ndarray)" args =>+           [NDArrayHandle] -> ArgsHMap "_Pad(ndarray)" args -> IO ()+_Pad_upd outputs args+  = let scalarArgs+          = catMaybes+              [("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["constant", "edge", "reflect"])),+               ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]),+               ("constant_value",) . showValue <$>+                 (args !? #constant_value :: Maybe Double)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pad"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_BatchNorm_v1(ndarray)" =+     '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float),+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),+        '("output_mean_var", AttrOpt Bool),+        '("data", AttrOpt NDArrayHandle),+        '("gamma", AttrOpt NDArrayHandle),+        '("beta", AttrOpt NDArrayHandle)]++_BatchNorm_v1 ::+              forall args . Fullfilled "_BatchNorm_v1(ndarray)" args =>+                ArgsHMap "_BatchNorm_v1(ndarray)" args -> IO [NDArrayHandle]+_BatchNorm_v1 args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BatchNorm_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_BatchNorm_v1_upd ::+                  forall args . Fullfilled "_BatchNorm_v1(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_BatchNorm_v1(ndarray)" args -> IO ()+_BatchNorm_v1_upd outputs args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BatchNorm_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "signsgd_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle)]++signsgd_update ::+               forall args . Fullfilled "signsgd_update(ndarray)" args =>+                 ArgsHMap "signsgd_update(ndarray)" args -> IO [NDArrayHandle]+signsgd_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "signsgd_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++signsgd_update_upd ::+                   forall args . Fullfilled "signsgd_update(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "signsgd_update(ndarray)" args -> IO ()+signsgd_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "signsgd_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "signum_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("wd_lh", AttrOpt Float),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle)]++signum_update ::+              forall args . Fullfilled "signum_update(ndarray)" args =>+                ArgsHMap "signum_update(ndarray)" args -> IO [NDArrayHandle]+signum_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("wd_lh",) . showValue <$> (args !? #wd_lh :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "signum_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++signum_update_upd ::+                  forall args . Fullfilled "signum_update(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "signum_update(ndarray)" args -> IO ()+signum_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("wd_lh",) . showValue <$> (args !? #wd_lh :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "signum_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "multi_sgd_update(ndarray)" =+     '[ '("lrs", AttrReq [Float]), '("wds", AttrReq [Float]),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int),+        '("data", AttrOpt [NDArrayHandle])]++multi_sgd_update ::+                 forall args . Fullfilled "multi_sgd_update(ndarray)" args =>+                   ArgsHMap "multi_sgd_update(ndarray)" args -> IO [NDArrayHandle]+multi_sgd_update args+  = let scalarArgs+          = catMaybes+              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),+               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("num_weights",) . showValue <$>+                 (args !? #num_weights :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "multi_sgd_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++multi_sgd_update_upd ::+                     forall args . Fullfilled "multi_sgd_update(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "multi_sgd_update(ndarray)" args -> IO ()+multi_sgd_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),+               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("num_weights",) . showValue <$>+                 (args !? #num_weights :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "multi_sgd_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "multi_sgd_mom_update(ndarray)" =+     '[ '("lrs", AttrReq [Float]), '("wds", AttrReq [Float]),+        '("momentum", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int),+        '("data", AttrOpt [NDArrayHandle])]++multi_sgd_mom_update ::+                     forall args . Fullfilled "multi_sgd_mom_update(ndarray)" args =>+                       ArgsHMap "multi_sgd_mom_update(ndarray)" args -> IO [NDArrayHandle]+multi_sgd_mom_update args+  = let scalarArgs+          = catMaybes+              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),+               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("num_weights",) . showValue <$>+                 (args !? #num_weights :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "multi_sgd_mom_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++multi_sgd_mom_update_upd ::+                         forall args . Fullfilled "multi_sgd_mom_update(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "multi_sgd_mom_update(ndarray)" args -> IO ()+multi_sgd_mom_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),+               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("num_weights",) . showValue <$>+                 (args !? #num_weights :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "multi_sgd_mom_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "multi_mp_sgd_update(ndarray)" =+     '[ '("lrs", AttrReq [Float]), '("wds", AttrReq [Float]),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int),+        '("data", AttrOpt [NDArrayHandle])]++multi_mp_sgd_update ::+                    forall args . Fullfilled "multi_mp_sgd_update(ndarray)" args =>+                      ArgsHMap "multi_mp_sgd_update(ndarray)" args -> IO [NDArrayHandle]+multi_mp_sgd_update args+  = let scalarArgs+          = catMaybes+              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),+               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("num_weights",) . showValue <$>+                 (args !? #num_weights :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "multi_mp_sgd_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++multi_mp_sgd_update_upd ::+                        forall args . Fullfilled "multi_mp_sgd_update(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "multi_mp_sgd_update(ndarray)" args -> IO ()+multi_mp_sgd_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),+               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("num_weights",) . showValue <$>+                 (args !? #num_weights :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "multi_mp_sgd_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "multi_mp_sgd_mom_update(ndarray)" =+     '[ '("lrs", AttrReq [Float]), '("wds", AttrReq [Float]),+        '("momentum", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int),+        '("data", AttrOpt [NDArrayHandle])]++multi_mp_sgd_mom_update ::+                        forall args . Fullfilled "multi_mp_sgd_mom_update(ndarray)" args =>+                          ArgsHMap "multi_mp_sgd_mom_update(ndarray)" args ->+                            IO [NDArrayHandle]+multi_mp_sgd_mom_update args+  = let scalarArgs+          = catMaybes+              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),+               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("num_weights",) . showValue <$>+                 (args !? #num_weights :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "multi_mp_sgd_mom_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++multi_mp_sgd_mom_update_upd ::+                            forall args . Fullfilled "multi_mp_sgd_mom_update(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "multi_mp_sgd_mom_update(ndarray)" args -> IO ()+multi_mp_sgd_mom_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),+               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("num_weights",) . showValue <$>+                 (args !? #num_weights :: Maybe Int)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "multi_mp_sgd_mom_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "sgd_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle)]++sgd_update ::+           forall args . Fullfilled "sgd_update(ndarray)" args =>+             ArgsHMap "sgd_update(ndarray)" args -> IO [NDArrayHandle]+sgd_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sgd_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++sgd_update_upd ::+               forall args . Fullfilled "sgd_update(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "sgd_update(ndarray)" args -> IO ()+sgd_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sgd_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "sgd_mom_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle)]++sgd_mom_update ::+               forall args . Fullfilled "sgd_mom_update(ndarray)" args =>+                 ArgsHMap "sgd_mom_update(ndarray)" args -> IO [NDArrayHandle]+sgd_mom_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sgd_mom_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++sgd_mom_update_upd ::+                   forall args . Fullfilled "sgd_mom_update(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "sgd_mom_update(ndarray)" args -> IO ()+sgd_mom_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sgd_mom_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "mp_sgd_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle),+        '("weight32", AttrOpt NDArrayHandle)]++mp_sgd_update ::+              forall args . Fullfilled "mp_sgd_update(ndarray)" args =>+                ArgsHMap "mp_sgd_update(ndarray)" args -> IO [NDArrayHandle]+mp_sgd_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mp_sgd_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++mp_sgd_update_upd ::+                  forall args . Fullfilled "mp_sgd_update(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "mp_sgd_update(ndarray)" args -> IO ()+mp_sgd_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mp_sgd_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "mp_sgd_mom_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle),+        '("weight32", AttrOpt NDArrayHandle)]++mp_sgd_mom_update ::+                  forall args . Fullfilled "mp_sgd_mom_update(ndarray)" args =>+                    ArgsHMap "mp_sgd_mom_update(ndarray)" args -> IO [NDArrayHandle]+mp_sgd_mom_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle),+               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mp_sgd_mom_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++mp_sgd_mom_update_upd ::+                      forall args . Fullfilled "mp_sgd_mom_update(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "mp_sgd_mom_update(ndarray)" args -> IO ()+mp_sgd_mom_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle),+               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mp_sgd_mom_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "ftml_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),+        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Double),+        '("t", AttrReq Int), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float), '("clip_grad", AttrOpt Float),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle), '("d", AttrOpt NDArrayHandle),+        '("v", AttrOpt NDArrayHandle), '("z", AttrOpt NDArrayHandle)]++ftml_update ::+            forall args . Fullfilled "ftml_update(ndarray)" args =>+              ArgsHMap "ftml_update(ndarray)" args -> IO [NDArrayHandle]+ftml_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Double),+               ("t",) . showValue <$> (args !? #t :: Maybe Int),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_grad",) . showValue <$> (args !? #clip_grad :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("d",) <$> (args !? #d :: Maybe NDArrayHandle),+               ("v",) <$> (args !? #v :: Maybe NDArrayHandle),+               ("z",) <$> (args !? #z :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ftml_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++ftml_update_upd ::+                forall args . Fullfilled "ftml_update(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "ftml_update(ndarray)" args -> IO ()+ftml_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Double),+               ("t",) . showValue <$> (args !? #t :: Maybe Int),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_grad",) . showValue <$> (args !? #clip_grad :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("d",) <$> (args !? #d :: Maybe NDArrayHandle),+               ("v",) <$> (args !? #v :: Maybe NDArrayHandle),+               ("z",) <$> (args !? #z :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ftml_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "adam_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),+        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle), '("mean", AttrOpt NDArrayHandle),+        '("var", AttrOpt NDArrayHandle)]++adam_update ::+            forall args . Fullfilled "adam_update(ndarray)" args =>+              ArgsHMap "adam_update(ndarray)" args -> IO [NDArrayHandle]+adam_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle),+               ("var",) <$> (args !? #var :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "adam_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++adam_update_upd ::+                forall args . Fullfilled "adam_update(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "adam_update(ndarray)" args -> IO ()+adam_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle),+               ("var",) <$> (args !? #var :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "adam_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "nag_mom_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle)]++nag_mom_update ::+               forall args . Fullfilled "nag_mom_update(ndarray)" args =>+                 ArgsHMap "nag_mom_update(ndarray)" args -> IO [NDArrayHandle]+nag_mom_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "nag_mom_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++nag_mom_update_upd ::+                   forall args . Fullfilled "nag_mom_update(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "nag_mom_update(ndarray)" args -> IO ()+nag_mom_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "nag_mom_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "mp_nag_mom_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle),+        '("weight32", AttrOpt NDArrayHandle)]++mp_nag_mom_update ::+                  forall args . Fullfilled "mp_nag_mom_update(ndarray)" args =>+                    ArgsHMap "mp_nag_mom_update(ndarray)" args -> IO [NDArrayHandle]+mp_nag_mom_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle),+               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mp_nag_mom_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++mp_nag_mom_update_upd ::+                      forall args . Fullfilled "mp_nag_mom_update(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "mp_nag_mom_update(ndarray)" args -> IO ()+mp_nag_mom_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle),+               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mp_nag_mom_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "rmsprop_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),+        '("epsilon", AttrOpt Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("clip_weights", AttrOpt Float),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle), '("n", AttrOpt NDArrayHandle)]++rmsprop_update ::+               forall args . Fullfilled "rmsprop_update(ndarray)" args =>+                 ArgsHMap "rmsprop_update(ndarray)" args -> IO [NDArrayHandle]+rmsprop_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("clip_weights",) . showValue <$>+                 (args !? #clip_weights :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("n",) <$> (args !? #n :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rmsprop_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++rmsprop_update_upd ::+                   forall args . Fullfilled "rmsprop_update(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "rmsprop_update(ndarray)" args -> IO ()+rmsprop_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("clip_weights",) . showValue <$>+                 (args !? #clip_weights :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("n",) <$> (args !? #n :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rmsprop_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "rmspropalex_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),+        '("gamma2", AttrOpt Float), '("epsilon", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("clip_weights", AttrOpt Float),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle), '("n", AttrOpt NDArrayHandle),+        '("g", AttrOpt NDArrayHandle), '("delta", AttrOpt NDArrayHandle)]++rmspropalex_update ::+                   forall args . Fullfilled "rmspropalex_update(ndarray)" args =>+                     ArgsHMap "rmspropalex_update(ndarray)" args -> IO [NDArrayHandle]+rmspropalex_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),+               ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("clip_weights",) . showValue <$>+                 (args !? #clip_weights :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("n",) <$> (args !? #n :: Maybe NDArrayHandle),+               ("g",) <$> (args !? #g :: Maybe NDArrayHandle),+               ("delta",) <$> (args !? #delta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rmspropalex_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++rmspropalex_update_upd ::+                       forall args . Fullfilled "rmspropalex_update(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "rmspropalex_update(ndarray)" args -> IO ()+rmspropalex_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),+               ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("clip_weights",) . showValue <$>+                 (args !? #clip_weights :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("n",) <$> (args !? #n :: Maybe NDArrayHandle),+               ("g",) <$> (args !? #g :: Maybe NDArrayHandle),+               ("delta",) <$> (args !? #delta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rmspropalex_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "ftrl_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("lamda1", AttrOpt Float),+        '("beta", AttrOpt Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle), '("z", AttrOpt NDArrayHandle),+        '("n", AttrOpt NDArrayHandle)]++ftrl_update ::+            forall args . Fullfilled "ftrl_update(ndarray)" args =>+              ArgsHMap "ftrl_update(ndarray)" args -> IO [NDArrayHandle]+ftrl_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("z",) <$> (args !? #z :: Maybe NDArrayHandle),+               ("n",) <$> (args !? #n :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ftrl_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++ftrl_update_upd ::+                forall args . Fullfilled "ftrl_update(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "ftrl_update(ndarray)" args -> IO ()+ftrl_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("z",) <$> (args !? #z :: Maybe NDArrayHandle),+               ("n",) <$> (args !? #n :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ftrl_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_sparse_adagrad_update(ndarray)" =+     '[ '("lr", AttrReq Float), '("epsilon", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt NDArrayHandle),+        '("grad", AttrOpt NDArrayHandle),+        '("history", AttrOpt NDArrayHandle)]++_sparse_adagrad_update ::+                       forall args . Fullfilled "_sparse_adagrad_update(ndarray)" args =>+                         ArgsHMap "_sparse_adagrad_update(ndarray)" args ->+                           IO [NDArrayHandle]+_sparse_adagrad_update args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("history",) <$> (args !? #history :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sparse_adagrad_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_sparse_adagrad_update_upd ::+                           forall args . Fullfilled "_sparse_adagrad_update(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_sparse_adagrad_update(ndarray)" args -> IO ()+_sparse_adagrad_update_upd outputs args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),+               ("history",) <$> (args !? #history :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sparse_adagrad_update"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_LinearRegressionOutput(ndarray)" =+     '[ '("grad_scale", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle),+        '("label", AttrOpt NDArrayHandle)]++_LinearRegressionOutput ::+                        forall args . Fullfilled "_LinearRegressionOutput(ndarray)" args =>+                          ArgsHMap "_LinearRegressionOutput(ndarray)" args ->+                            IO [NDArrayHandle]+_LinearRegressionOutput args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LinearRegressionOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_LinearRegressionOutput_upd ::+                            forall args . Fullfilled "_LinearRegressionOutput(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_LinearRegressionOutput(ndarray)" args -> IO ()+_LinearRegressionOutput_upd outputs args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LinearRegressionOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_linear_reg_out(ndarray)" =+     '[]++_backward_linear_reg_out ::+                         forall args .+                           Fullfilled "_backward_linear_reg_out(ndarray)" args =>+                           ArgsHMap "_backward_linear_reg_out(ndarray)" args ->+                             IO [NDArrayHandle]+_backward_linear_reg_out args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linear_reg_out"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_linear_reg_out_upd ::+                             forall args .+                               Fullfilled "_backward_linear_reg_out(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_backward_linear_reg_out(ndarray)" args -> IO ()+_backward_linear_reg_out_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linear_reg_out"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_MAERegressionOutput(ndarray)" =+     '[ '("grad_scale", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle),+        '("label", AttrOpt NDArrayHandle)]++_MAERegressionOutput ::+                     forall args . Fullfilled "_MAERegressionOutput(ndarray)" args =>+                       ArgsHMap "_MAERegressionOutput(ndarray)" args -> IO [NDArrayHandle]+_MAERegressionOutput args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "MAERegressionOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_MAERegressionOutput_upd ::+                         forall args . Fullfilled "_MAERegressionOutput(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_MAERegressionOutput(ndarray)" args -> IO ()+_MAERegressionOutput_upd outputs args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "MAERegressionOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_mae_reg_out(ndarray)" = '[]++_backward_mae_reg_out ::+                      forall args . Fullfilled "_backward_mae_reg_out(ndarray)" args =>+                        ArgsHMap "_backward_mae_reg_out(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_mae_reg_out args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mae_reg_out"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_mae_reg_out_upd ::+                          forall args . Fullfilled "_backward_mae_reg_out(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_mae_reg_out(ndarray)" args -> IO ()+_backward_mae_reg_out_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mae_reg_out"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_LogisticRegressionOutput(ndarray)" =+     '[ '("grad_scale", AttrOpt Float),+        '("data", AttrOpt NDArrayHandle),+        '("label", AttrOpt NDArrayHandle)]++_LogisticRegressionOutput ::+                          forall args .+                            Fullfilled "_LogisticRegressionOutput(ndarray)" args =>+                            ArgsHMap "_LogisticRegressionOutput(ndarray)" args ->+                              IO [NDArrayHandle]+_LogisticRegressionOutput args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LogisticRegressionOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_LogisticRegressionOutput_upd ::+                              forall args .+                                Fullfilled "_LogisticRegressionOutput(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_LogisticRegressionOutput(ndarray)" args -> IO ()+_LogisticRegressionOutput_upd outputs args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LogisticRegressionOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_logistic_reg_out(ndarray)" =+     '[]++_backward_logistic_reg_out ::+                           forall args .+                             Fullfilled "_backward_logistic_reg_out(ndarray)" args =>+                             ArgsHMap "_backward_logistic_reg_out(ndarray)" args ->+                               IO [NDArrayHandle]+_backward_logistic_reg_out args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_logistic_reg_out"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_logistic_reg_out_upd ::+                               forall args .+                                 Fullfilled "_backward_logistic_reg_out(ndarray)" args =>+                                 [NDArrayHandle] ->+                                   ArgsHMap "_backward_logistic_reg_out(ndarray)" args -> IO ()+_backward_logistic_reg_out_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_logistic_reg_out"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_CustomFunction(ndarray)" = '[]++_CustomFunction ::+                forall args . Fullfilled "_CustomFunction(ndarray)" args =>+                  ArgsHMap "_CustomFunction(ndarray)" args -> IO [NDArrayHandle]+_CustomFunction args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_CustomFunction"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_CustomFunction_upd ::+                    forall args . Fullfilled "_CustomFunction(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_CustomFunction(ndarray)" args -> IO ()+_CustomFunction_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_CustomFunction"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_CustomFunction(ndarray)" =+     '[]++_backward_CustomFunction ::+                         forall args .+                           Fullfilled "_backward_CustomFunction(ndarray)" args =>+                           ArgsHMap "_backward_CustomFunction(ndarray)" args ->+                             IO [NDArrayHandle]+_backward_CustomFunction args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_CustomFunction"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_CustomFunction_upd ::+                             forall args .+                               Fullfilled "_backward_CustomFunction(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_backward_CustomFunction(ndarray)" args -> IO ()+_backward_CustomFunction_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_CustomFunction"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward__Native(ndarray)" = '[]++_backward__Native ::+                  forall args . Fullfilled "_backward__Native(ndarray)" args =>+                    ArgsHMap "_backward__Native(ndarray)" args -> IO [NDArrayHandle]+_backward__Native args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__Native"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__Native_upd ::+                      forall args . Fullfilled "_backward__Native(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_backward__Native(ndarray)" args -> IO ()+_backward__Native_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__Native"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward__NDArray(ndarray)" = '[]++_backward__NDArray ::+                   forall args . Fullfilled "_backward__NDArray(ndarray)" args =>+                     ArgsHMap "_backward__NDArray(ndarray)" args -> IO [NDArrayHandle]+_backward__NDArray args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__NDArray"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__NDArray_upd ::+                       forall args . Fullfilled "_backward__NDArray(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_backward__NDArray(ndarray)" args -> IO ()+_backward__NDArray_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__NDArray"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_MultiBoxTarget(ndarray)" =+     '[ '("overlap_threshold", AttrOpt Float),+        '("ignore_label", AttrOpt Float),+        '("negative_mining_ratio", AttrOpt Float),+        '("negative_mining_thresh", AttrOpt Float),+        '("minimum_negative_samples", AttrOpt Int),+        '("variances", AttrOpt [Float]),+        '("anchor", AttrOpt NDArrayHandle),+        '("label", AttrOpt NDArrayHandle),+        '("cls_pred", AttrOpt NDArrayHandle)]++_contrib_MultiBoxTarget ::+                        forall args . Fullfilled "_contrib_MultiBoxTarget(ndarray)" args =>+                          ArgsHMap "_contrib_MultiBoxTarget(ndarray)" args ->+                            IO [NDArrayHandle]+_contrib_MultiBoxTarget args+  = let scalarArgs+          = catMaybes+              [("overlap_threshold",) . showValue <$>+                 (args !? #overlap_threshold :: Maybe Float),+               ("ignore_label",) . showValue <$>+                 (args !? #ignore_label :: Maybe Float),+               ("negative_mining_ratio",) . showValue <$>+                 (args !? #negative_mining_ratio :: Maybe Float),+               ("negative_mining_thresh",) . showValue <$>+                 (args !? #negative_mining_thresh :: Maybe Float),+               ("minimum_negative_samples",) . showValue <$>+                 (args !? #minimum_negative_samples :: Maybe Int),+               ("variances",) . showValue <$>+                 (args !? #variances :: Maybe [Float])]+        tensorArgs+          = catMaybes+              [("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle),+               ("cls_pred",) <$> (args !? #cls_pred :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxTarget"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_MultiBoxTarget_upd ::+                            forall args . Fullfilled "_contrib_MultiBoxTarget(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_contrib_MultiBoxTarget(ndarray)" args -> IO ()+_contrib_MultiBoxTarget_upd outputs args+  = let scalarArgs+          = catMaybes+              [("overlap_threshold",) . showValue <$>+                 (args !? #overlap_threshold :: Maybe Float),+               ("ignore_label",) . showValue <$>+                 (args !? #ignore_label :: Maybe Float),+               ("negative_mining_ratio",) . showValue <$>+                 (args !? #negative_mining_ratio :: Maybe Float),+               ("negative_mining_thresh",) . showValue <$>+                 (args !? #negative_mining_thresh :: Maybe Float),+               ("minimum_negative_samples",) . showValue <$>+                 (args !? #minimum_negative_samples :: Maybe Int),+               ("variances",) . showValue <$>+                 (args !? #variances :: Maybe [Float])]+        tensorArgs+          = catMaybes+              [("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle),+               ("cls_pred",) <$> (args !? #cls_pred :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxTarget"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward__contrib_MultiBoxTarget(ndarray)" = '[]++_backward__contrib_MultiBoxTarget ::+                                  forall args .+                                    Fullfilled "_backward__contrib_MultiBoxTarget(ndarray)" args =>+                                    ArgsHMap "_backward__contrib_MultiBoxTarget(ndarray)" args ->+                                      IO [NDArrayHandle]+_backward__contrib_MultiBoxTarget args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_MultiBoxTarget_upd ::+                                      forall args .+                                        Fullfilled "_backward__contrib_MultiBoxTarget(ndarray)"+                                          args =>+                                        [NDArrayHandle] ->+                                          ArgsHMap "_backward__contrib_MultiBoxTarget(ndarray)" args+                                            -> IO ()+_backward__contrib_MultiBoxTarget_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_Proposal(ndarray)" =+     '[ '("rpn_pre_nms_top_n", AttrOpt Int),+        '("rpn_post_nms_top_n", AttrOpt Int),+        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),+        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),+        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),+        '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt NDArrayHandle),+        '("bbox_pred", AttrOpt NDArrayHandle),+        '("im_info", AttrOpt NDArrayHandle)]++_contrib_Proposal ::+                  forall args . Fullfilled "_contrib_Proposal(ndarray)" args =>+                    ArgsHMap "_contrib_Proposal(ndarray)" args -> IO [NDArrayHandle]+_contrib_Proposal args+  = let scalarArgs+          = catMaybes+              [("rpn_pre_nms_top_n",) . showValue <$>+                 (args !? #rpn_pre_nms_top_n :: Maybe Int),+               ("rpn_post_nms_top_n",) . showValue <$>+                 (args !? #rpn_post_nms_top_n :: Maybe Int),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("rpn_min_size",) . showValue <$>+                 (args !? #rpn_min_size :: Maybe Int),+               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("feature_stride",) . showValue <$>+                 (args !? #feature_stride :: Maybe Int),+               ("output_score",) . showValue <$>+                 (args !? #output_score :: Maybe Bool),+               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),+               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle),+               ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_Proposal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_Proposal_upd ::+                      forall args . Fullfilled "_contrib_Proposal(ndarray)" args =>+                        [NDArrayHandle] ->+                          ArgsHMap "_contrib_Proposal(ndarray)" args -> IO ()+_contrib_Proposal_upd outputs args+  = let scalarArgs+          = catMaybes+              [("rpn_pre_nms_top_n",) . showValue <$>+                 (args !? #rpn_pre_nms_top_n :: Maybe Int),+               ("rpn_post_nms_top_n",) . showValue <$>+                 (args !? #rpn_post_nms_top_n :: Maybe Int),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("rpn_min_size",) . showValue <$>+                 (args !? #rpn_min_size :: Maybe Int),+               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("feature_stride",) . showValue <$>+                 (args !? #feature_stride :: Maybe Int),+               ("output_score",) . showValue <$>+                 (args !? #output_score :: Maybe Bool),+               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),+               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle),+               ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_Proposal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward__contrib_Proposal(ndarray)"+     = '[]++_backward__contrib_Proposal ::+                            forall args .+                              Fullfilled "_backward__contrib_Proposal(ndarray)" args =>+                              ArgsHMap "_backward__contrib_Proposal(ndarray)" args ->+                                IO [NDArrayHandle]+_backward__contrib_Proposal args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_Proposal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_Proposal_upd ::+                                forall args .+                                  Fullfilled "_backward__contrib_Proposal(ndarray)" args =>+                                  [NDArrayHandle] ->+                                    ArgsHMap "_backward__contrib_Proposal(ndarray)" args -> IO ()+_backward__contrib_Proposal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_Proposal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_count_sketch(ndarray)" =+     '[ '("out_dim", AttrReq Int),+        '("processing_batch_size", AttrOpt Int),+        '("data", AttrOpt NDArrayHandle), '("h", AttrOpt NDArrayHandle),+        '("s", AttrOpt NDArrayHandle)]++_contrib_count_sketch ::+                      forall args . Fullfilled "_contrib_count_sketch(ndarray)" args =>+                        ArgsHMap "_contrib_count_sketch(ndarray)" args ->+                          IO [NDArrayHandle]+_contrib_count_sketch args+  = let scalarArgs+          = catMaybes+              [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int),+               ("processing_batch_size",) . showValue <$>+                 (args !? #processing_batch_size :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("h",) <$> (args !? #h :: Maybe NDArrayHandle),+               ("s",) <$> (args !? #s :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_count_sketch"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_count_sketch_upd ::+                          forall args . Fullfilled "_contrib_count_sketch(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_contrib_count_sketch(ndarray)" args -> IO ()+_contrib_count_sketch_upd outputs args+  = let scalarArgs+          = catMaybes+              [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int),+               ("processing_batch_size",) . showValue <$>+                 (args !? #processing_batch_size :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("h",) <$> (args !? #h :: Maybe NDArrayHandle),+               ("s",) <$> (args !? #s :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_count_sketch"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward__contrib_count_sketch(ndarray)" = '[]++_backward__contrib_count_sketch ::+                                forall args .+                                  Fullfilled "_backward__contrib_count_sketch(ndarray)" args =>+                                  ArgsHMap "_backward__contrib_count_sketch(ndarray)" args ->+                                    IO [NDArrayHandle]+_backward__contrib_count_sketch args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_count_sketch"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_count_sketch_upd ::+                                    forall args .+                                      Fullfilled "_backward__contrib_count_sketch(ndarray)" args =>+                                      [NDArrayHandle] ->+                                        ArgsHMap "_backward__contrib_count_sketch(ndarray)" args ->+                                          IO ()+_backward__contrib_count_sketch_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_count_sketch"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_MultiBoxDetection(ndarray)" =+     '[ '("clip", AttrOpt Bool), '("threshold", AttrOpt Float),+        '("background_id", AttrOpt Int), '("nms_threshold", AttrOpt Float),+        '("force_suppress", AttrOpt Bool), '("variances", AttrOpt [Float]),+        '("nms_topk", AttrOpt Int), '("cls_prob", AttrOpt NDArrayHandle),+        '("loc_pred", AttrOpt NDArrayHandle),+        '("anchor", AttrOpt NDArrayHandle)]++_contrib_MultiBoxDetection ::+                           forall args .+                             Fullfilled "_contrib_MultiBoxDetection(ndarray)" args =>+                             ArgsHMap "_contrib_MultiBoxDetection(ndarray)" args ->+                               IO [NDArrayHandle]+_contrib_MultiBoxDetection args+  = let scalarArgs+          = catMaybes+              [("clip",) . showValue <$> (args !? #clip :: Maybe Bool),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("background_id",) . showValue <$>+                 (args !? #background_id :: Maybe Int),+               ("nms_threshold",) . showValue <$>+                 (args !? #nms_threshold :: Maybe Float),+               ("force_suppress",) . showValue <$>+                 (args !? #force_suppress :: Maybe Bool),+               ("variances",) . showValue <$>+                 (args !? #variances :: Maybe [Float]),+               ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),+               ("loc_pred",) <$> (args !? #loc_pred :: Maybe NDArrayHandle),+               ("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxDetection"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_MultiBoxDetection_upd ::+                               forall args .+                                 Fullfilled "_contrib_MultiBoxDetection(ndarray)" args =>+                                 [NDArrayHandle] ->+                                   ArgsHMap "_contrib_MultiBoxDetection(ndarray)" args -> IO ()+_contrib_MultiBoxDetection_upd outputs args+  = let scalarArgs+          = catMaybes+              [("clip",) . showValue <$> (args !? #clip :: Maybe Bool),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("background_id",) . showValue <$>+                 (args !? #background_id :: Maybe Int),+               ("nms_threshold",) . showValue <$>+                 (args !? #nms_threshold :: Maybe Float),+               ("force_suppress",) . showValue <$>+                 (args !? #force_suppress :: Maybe Bool),+               ("variances",) . showValue <$>+                 (args !? #variances :: Maybe [Float]),+               ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),+               ("loc_pred",) <$> (args !? #loc_pred :: Maybe NDArrayHandle),+               ("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxDetection"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward__contrib_MultiBoxDetection(ndarray)" = '[]++_backward__contrib_MultiBoxDetection ::+                                     forall args .+                                       Fullfilled "_backward__contrib_MultiBoxDetection(ndarray)"+                                         args =>+                                       ArgsHMap "_backward__contrib_MultiBoxDetection(ndarray)" args+                                         -> IO [NDArrayHandle]+_backward__contrib_MultiBoxDetection args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_MultiBoxDetection_upd ::+                                         forall args .+                                           Fullfilled+                                             "_backward__contrib_MultiBoxDetection(ndarray)" args =>+                                           [NDArrayHandle] ->+                                             ArgsHMap+                                               "_backward__contrib_MultiBoxDetection(ndarray)"+                                               args+                                               -> IO ()+_backward__contrib_MultiBoxDetection_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward__contrib_DeformablePSROIPooling(ndarray)"+     = '[]++_backward__contrib_DeformablePSROIPooling ::+                                          forall args .+                                            Fullfilled+                                              "_backward__contrib_DeformablePSROIPooling(ndarray)"+                                              args =>+                                            ArgsHMap+                                              "_backward__contrib_DeformablePSROIPooling(ndarray)"+                                              args+                                              -> IO [NDArrayHandle]+_backward__contrib_DeformablePSROIPooling args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_DeformablePSROIPooling_upd ::+                                              forall args .+                                                Fullfilled+                                                  "_backward__contrib_DeformablePSROIPooling(ndarray)"+                                                  args =>+                                                [NDArrayHandle] ->+                                                  ArgsHMap+                                                    "_backward__contrib_DeformablePSROIPooling(ndarray)"+                                                    args+                                                    -> IO ()+_backward__contrib_DeformablePSROIPooling_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_fft(ndarray)" =+     '[ '("compute_size", AttrOpt Int),+        '("data", AttrOpt NDArrayHandle)]++_contrib_fft ::+             forall args . Fullfilled "_contrib_fft(ndarray)" args =>+               ArgsHMap "_contrib_fft(ndarray)" args -> IO [NDArrayHandle]+_contrib_fft args+  = let scalarArgs+          = catMaybes+              [("compute_size",) . showValue <$>+                 (args !? #compute_size :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_fft"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_fft_upd ::+                 forall args . Fullfilled "_contrib_fft(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_contrib_fft(ndarray)" args -> IO ()+_contrib_fft_upd outputs args+  = let scalarArgs+          = catMaybes+              [("compute_size",) . showValue <$>+                 (args !? #compute_size :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_fft"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward__contrib_fft(ndarray)" = '[]++_backward__contrib_fft ::+                       forall args . Fullfilled "_backward__contrib_fft(ndarray)" args =>+                         ArgsHMap "_backward__contrib_fft(ndarray)" args ->+                           IO [NDArrayHandle]+_backward__contrib_fft args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_fft"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_fft_upd ::+                           forall args . Fullfilled "_backward__contrib_fft(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward__contrib_fft(ndarray)" args -> IO ()+_backward__contrib_fft_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_fft"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_MultiBoxPrior(ndarray)" =+     '[ '("sizes", AttrOpt [Float]), '("ratios", AttrOpt [Float]),+        '("clip", AttrOpt Bool), '("steps", AttrOpt [Float]),+        '("offsets", AttrOpt [Float]), '("data", AttrOpt NDArrayHandle)]++_contrib_MultiBoxPrior ::+                       forall args . Fullfilled "_contrib_MultiBoxPrior(ndarray)" args =>+                         ArgsHMap "_contrib_MultiBoxPrior(ndarray)" args ->+                           IO [NDArrayHandle]+_contrib_MultiBoxPrior args+  = let scalarArgs+          = catMaybes+              [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("clip",) . showValue <$> (args !? #clip :: Maybe Bool),+               ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]),+               ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxPrior"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_MultiBoxPrior_upd ::+                           forall args . Fullfilled "_contrib_MultiBoxPrior(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_contrib_MultiBoxPrior(ndarray)" args -> IO ()+_contrib_MultiBoxPrior_upd outputs args+  = let scalarArgs+          = catMaybes+              [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("clip",) . showValue <$> (args !? #clip :: Maybe Bool),+               ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]),+               ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxPrior"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward__contrib_MultiBoxPrior(ndarray)" = '[]++_backward__contrib_MultiBoxPrior ::+                                 forall args .+                                   Fullfilled "_backward__contrib_MultiBoxPrior(ndarray)" args =>+                                   ArgsHMap "_backward__contrib_MultiBoxPrior(ndarray)" args ->+                                     IO [NDArrayHandle]+_backward__contrib_MultiBoxPrior args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_MultiBoxPrior_upd ::+                                     forall args .+                                       Fullfilled "_backward__contrib_MultiBoxPrior(ndarray)"+                                         args =>+                                       [NDArrayHandle] ->+                                         ArgsHMap "_backward__contrib_MultiBoxPrior(ndarray)" args+                                           -> IO ()+_backward__contrib_MultiBoxPrior_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_MultiProposal(ndarray)" =+     '[ '("rpn_pre_nms_top_n", AttrOpt Int),+        '("rpn_post_nms_top_n", AttrOpt Int),+        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),+        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),+        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),+        '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt NDArrayHandle),+        '("bbox_pred", AttrOpt NDArrayHandle),+        '("im_info", AttrOpt NDArrayHandle)]++_contrib_MultiProposal ::+                       forall args . Fullfilled "_contrib_MultiProposal(ndarray)" args =>+                         ArgsHMap "_contrib_MultiProposal(ndarray)" args ->+                           IO [NDArrayHandle]+_contrib_MultiProposal args+  = let scalarArgs+          = catMaybes+              [("rpn_pre_nms_top_n",) . showValue <$>+                 (args !? #rpn_pre_nms_top_n :: Maybe Int),+               ("rpn_post_nms_top_n",) . showValue <$>+                 (args !? #rpn_post_nms_top_n :: Maybe Int),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("rpn_min_size",) . showValue <$>+                 (args !? #rpn_min_size :: Maybe Int),+               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("feature_stride",) . showValue <$>+                 (args !? #feature_stride :: Maybe Int),+               ("output_score",) . showValue <$>+                 (args !? #output_score :: Maybe Bool),+               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),+               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle),+               ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiProposal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_MultiProposal_upd ::+                           forall args . Fullfilled "_contrib_MultiProposal(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_contrib_MultiProposal(ndarray)" args -> IO ()+_contrib_MultiProposal_upd outputs args+  = let scalarArgs+          = catMaybes+              [("rpn_pre_nms_top_n",) . showValue <$>+                 (args !? #rpn_pre_nms_top_n :: Maybe Int),+               ("rpn_post_nms_top_n",) . showValue <$>+                 (args !? #rpn_post_nms_top_n :: Maybe Int),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("rpn_min_size",) . showValue <$>+                 (args !? #rpn_min_size :: Maybe Int),+               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("feature_stride",) . showValue <$>+                 (args !? #feature_stride :: Maybe Int),+               ("output_score",) . showValue <$>+                 (args !? #output_score :: Maybe Bool),+               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),+               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle),+               ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiProposal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward__contrib_MultiProposal(ndarray)" = '[]++_backward__contrib_MultiProposal ::+                                 forall args .+                                   Fullfilled "_backward__contrib_MultiProposal(ndarray)" args =>+                                   ArgsHMap "_backward__contrib_MultiProposal(ndarray)" args ->+                                     IO [NDArrayHandle]+_backward__contrib_MultiProposal args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiProposal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_MultiProposal_upd ::+                                     forall args .+                                       Fullfilled "_backward__contrib_MultiProposal(ndarray)"+                                         args =>+                                       [NDArrayHandle] ->+                                         ArgsHMap "_backward__contrib_MultiProposal(ndarray)" args+                                           -> IO ()+_backward__contrib_MultiProposal_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiProposal"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward__contrib_PSROIPooling(ndarray)" = '[]++_backward__contrib_PSROIPooling ::+                                forall args .+                                  Fullfilled "_backward__contrib_PSROIPooling(ndarray)" args =>+                                  ArgsHMap "_backward__contrib_PSROIPooling(ndarray)" args ->+                                    IO [NDArrayHandle]+_backward__contrib_PSROIPooling args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_PSROIPooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_PSROIPooling_upd ::+                                    forall args .+                                      Fullfilled "_backward__contrib_PSROIPooling(ndarray)" args =>+                                      [NDArrayHandle] ->+                                        ArgsHMap "_backward__contrib_PSROIPooling(ndarray)" args ->+                                          IO ()+_backward__contrib_PSROIPooling_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_PSROIPooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_contrib_DeformableConvolution(ndarray)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("num_deformable_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("layout", AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NCW"]))),+        '("data", AttrOpt NDArrayHandle),+        '("offset", AttrOpt NDArrayHandle),+        '("weight", AttrOpt NDArrayHandle),+        '("bias", AttrOpt NDArrayHandle)]++_contrib_DeformableConvolution ::+                               forall args .+                                 Fullfilled "_contrib_DeformableConvolution(ndarray)" args =>+                                 ArgsHMap "_contrib_DeformableConvolution(ndarray)" args ->+                                   IO [NDArrayHandle]+_contrib_DeformableConvolution args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("num_deformable_group",) . showValue <$>+                 (args !? #num_deformable_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("offset",) <$> (args !? #offset :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_DeformableConvolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_DeformableConvolution_upd ::+                                   forall args .+                                     Fullfilled "_contrib_DeformableConvolution(ndarray)" args =>+                                     [NDArrayHandle] ->+                                       ArgsHMap "_contrib_DeformableConvolution(ndarray)" args ->+                                         IO ()+_contrib_DeformableConvolution_upd outputs args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("num_deformable_group",) . showValue <$>+                 (args !? #num_deformable_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("offset",) <$> (args !? #offset :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_DeformableConvolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward__contrib_DeformableConvolution(ndarray)" =+     '[]++_backward__contrib_DeformableConvolution ::+                                         forall args .+                                           Fullfilled+                                             "_backward__contrib_DeformableConvolution(ndarray)"+                                             args =>+                                           ArgsHMap+                                             "_backward__contrib_DeformableConvolution(ndarray)"+                                             args+                                             -> IO [NDArrayHandle]+_backward__contrib_DeformableConvolution args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_DeformableConvolution_upd ::+                                             forall args .+                                               Fullfilled+                                                 "_backward__contrib_DeformableConvolution(ndarray)"+                                                 args =>+                                               [NDArrayHandle] ->+                                                 ArgsHMap+                                                   "_backward__contrib_DeformableConvolution(ndarray)"+                                                   args+                                                   -> IO ()+_backward__contrib_DeformableConvolution_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_contrib_ifft(ndarray)" =+     '[ '("compute_size", AttrOpt Int),+        '("data", AttrOpt NDArrayHandle)]++_contrib_ifft ::+              forall args . Fullfilled "_contrib_ifft(ndarray)" args =>+                ArgsHMap "_contrib_ifft(ndarray)" args -> IO [NDArrayHandle]+_contrib_ifft args+  = let scalarArgs+          = catMaybes+              [("compute_size",) . showValue <$>+                 (args !? #compute_size :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_ifft"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_contrib_ifft_upd ::+                  forall args . Fullfilled "_contrib_ifft(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_contrib_ifft(ndarray)" args -> IO ()+_contrib_ifft_upd outputs args+  = let scalarArgs+          = catMaybes+              [("compute_size",) . showValue <$>+                 (args !? #compute_size :: Maybe Int)]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_ifft"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward__contrib_ifft(ndarray)" =+     '[]++_backward__contrib_ifft ::+                        forall args . Fullfilled "_backward__contrib_ifft(ndarray)" args =>+                          ArgsHMap "_backward__contrib_ifft(ndarray)" args ->+                            IO [NDArrayHandle]+_backward__contrib_ifft args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_ifft"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_ifft_upd ::+                            forall args . Fullfilled "_backward__contrib_ifft(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward__contrib_ifft(ndarray)" args -> IO ()+_backward__contrib_ifft_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_ifft"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward__contrib_SyncBatchNorm(ndarray)" = '[]++_backward__contrib_SyncBatchNorm ::+                                 forall args .+                                   Fullfilled "_backward__contrib_SyncBatchNorm(ndarray)" args =>+                                   ArgsHMap "_backward__contrib_SyncBatchNorm(ndarray)" args ->+                                     IO [NDArrayHandle]+_backward__contrib_SyncBatchNorm args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_SyncBatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__contrib_SyncBatchNorm_upd ::+                                     forall args .+                                       Fullfilled "_backward__contrib_SyncBatchNorm(ndarray)"+                                         args =>+                                       [NDArrayHandle] ->+                                         ArgsHMap "_backward__contrib_SyncBatchNorm(ndarray)" args+                                           -> IO ()+_backward__contrib_SyncBatchNorm_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_SyncBatchNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_InstanceNorm(ndarray)" =+     '[ '("eps", AttrOpt Float), '("data", AttrOpt NDArrayHandle),+        '("gamma", AttrOpt NDArrayHandle),+        '("beta", AttrOpt NDArrayHandle)]++_InstanceNorm ::+              forall args . Fullfilled "_InstanceNorm(ndarray)" args =>+                ArgsHMap "_InstanceNorm(ndarray)" args -> IO [NDArrayHandle]+_InstanceNorm args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "InstanceNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_InstanceNorm_upd ::+                  forall args . Fullfilled "_InstanceNorm(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_InstanceNorm(ndarray)" args -> IO ()+_InstanceNorm_upd outputs args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),+               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "InstanceNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_InstanceNorm(ndarray)" = '[]++_backward_InstanceNorm ::+                       forall args . Fullfilled "_backward_InstanceNorm(ndarray)" args =>+                         ArgsHMap "_backward_InstanceNorm(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_InstanceNorm args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_InstanceNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_InstanceNorm_upd ::+                           forall args . Fullfilled "_backward_InstanceNorm(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_InstanceNorm(ndarray)" args -> IO ()+_backward_InstanceNorm_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_InstanceNorm"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_SVMOutput(ndarray)" =+     '[ '("margin", AttrOpt Float),+        '("regularization_coefficient", AttrOpt Float),+        '("use_linear", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),+        '("label", AttrOpt NDArrayHandle)]++_SVMOutput ::+           forall args . Fullfilled "_SVMOutput(ndarray)" args =>+             ArgsHMap "_SVMOutput(ndarray)" args -> IO [NDArrayHandle]+_SVMOutput args+  = let scalarArgs+          = catMaybes+              [("margin",) . showValue <$> (args !? #margin :: Maybe Float),+               ("regularization_coefficient",) . showValue <$>+                 (args !? #regularization_coefficient :: Maybe Float),+               ("use_linear",) . showValue <$>+                 (args !? #use_linear :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SVMOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_SVMOutput_upd ::+               forall args . Fullfilled "_SVMOutput(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "_SVMOutput(ndarray)" args -> IO ()+_SVMOutput_upd outputs args+  = let scalarArgs+          = catMaybes+              [("margin",) . showValue <$> (args !? #margin :: Maybe Float),+               ("regularization_coefficient",) . showValue <$>+                 (args !? #regularization_coefficient :: Maybe Float),+               ("use_linear",) . showValue <$>+                 (args !? #use_linear :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SVMOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SVMOutput(ndarray)" = '[]++_backward_SVMOutput ::+                    forall args . Fullfilled "_backward_SVMOutput(ndarray)" args =>+                      ArgsHMap "_backward_SVMOutput(ndarray)" args -> IO [NDArrayHandle]+_backward_SVMOutput args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SVMOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SVMOutput_upd ::+                        forall args . Fullfilled "_backward_SVMOutput(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_backward_SVMOutput(ndarray)" args -> IO ()+_backward_SVMOutput_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SVMOutput"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_GridGenerator(ndarray)" =+     '[ '("transform_type", AttrReq (EnumType '["affine", "warp"])),+        '("target_shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]++_GridGenerator ::+               forall args . Fullfilled "_GridGenerator(ndarray)" args =>+                 ArgsHMap "_GridGenerator(ndarray)" args -> IO [NDArrayHandle]+_GridGenerator args+  = let scalarArgs+          = catMaybes+              [("transform_type",) . showValue <$>+                 (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "GridGenerator"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_GridGenerator_upd ::+                   forall args . Fullfilled "_GridGenerator(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_GridGenerator(ndarray)" args -> IO ()+_GridGenerator_upd outputs args+  = let scalarArgs+          = catMaybes+              [("transform_type",) . showValue <$>+                 (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "GridGenerator"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_GridGenerator(ndarray)" =+     '[]++_backward_GridGenerator ::+                        forall args . Fullfilled "_backward_GridGenerator(ndarray)" args =>+                          ArgsHMap "_backward_GridGenerator(ndarray)" args ->+                            IO [NDArrayHandle]+_backward_GridGenerator args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_GridGenerator"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_GridGenerator_upd ::+                            forall args . Fullfilled "_backward_GridGenerator(ndarray)" args =>+                              [NDArrayHandle] ->+                                ArgsHMap "_backward_GridGenerator(ndarray)" args -> IO ()+_backward_GridGenerator_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_GridGenerator"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Convolution_v1(ndarray)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("cudnn_tune",+          AttrOpt+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+        '("cudnn_off", AttrOpt Bool),+        '("layout",+          AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"]))),+        '("data", AttrOpt NDArrayHandle),+        '("weight", AttrOpt NDArrayHandle),+        '("bias", AttrOpt NDArrayHandle)]++_Convolution_v1 ::+                forall args . Fullfilled "_Convolution_v1(ndarray)" args =>+                  ArgsHMap "_Convolution_v1(ndarray)" args -> IO [NDArrayHandle]+_Convolution_v1 args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Convolution_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Convolution_v1_upd ::+                    forall args . Fullfilled "_Convolution_v1(ndarray)" args =>+                      [NDArrayHandle] ->+                        ArgsHMap "_Convolution_v1(ndarray)" args -> IO ()+_Convolution_v1_upd outputs args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),+               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Convolution_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Convolution_v1(ndarray)" =+     '[]++_backward_Convolution_v1 ::+                         forall args .+                           Fullfilled "_backward_Convolution_v1(ndarray)" args =>+                           ArgsHMap "_backward_Convolution_v1(ndarray)" args ->+                             IO [NDArrayHandle]+_backward_Convolution_v1 args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Convolution_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Convolution_v1_upd ::+                             forall args .+                               Fullfilled "_backward_Convolution_v1(ndarray)" args =>+                               [NDArrayHandle] ->+                                 ArgsHMap "_backward_Convolution_v1(ndarray)" args -> IO ()+_backward_Convolution_v1_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Convolution_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_SequenceReverse(ndarray)" =+     '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int),+        '("data", AttrOpt NDArrayHandle),+        '("sequence_length", AttrOpt NDArrayHandle)]++_SequenceReverse ::+                 forall args . Fullfilled "_SequenceReverse(ndarray)" args =>+                   ArgsHMap "_SequenceReverse(ndarray)" args -> IO [NDArrayHandle]+_SequenceReverse args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceReverse"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_SequenceReverse_upd ::+                     forall args . Fullfilled "_SequenceReverse(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_SequenceReverse(ndarray)" args -> IO ()+_SequenceReverse_upd outputs args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceReverse"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SequenceReverse(ndarray)" =+     '[]++_backward_SequenceReverse ::+                          forall args .+                            Fullfilled "_backward_SequenceReverse(ndarray)" args =>+                            ArgsHMap "_backward_SequenceReverse(ndarray)" args ->+                              IO [NDArrayHandle]+_backward_SequenceReverse args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceReverse"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SequenceReverse_upd ::+                              forall args .+                                Fullfilled "_backward_SequenceReverse(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_backward_SequenceReverse(ndarray)" args -> IO ()+_backward_SequenceReverse_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceReverse"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_BilinearSampler(ndarray)" =+     '[ '("cudnn_off", AttrOpt (Maybe Bool)),+        '("data", AttrOpt NDArrayHandle), '("grid", AttrOpt NDArrayHandle)]++_BilinearSampler ::+                 forall args . Fullfilled "_BilinearSampler(ndarray)" args =>+                   ArgsHMap "_BilinearSampler(ndarray)" args -> IO [NDArrayHandle]+_BilinearSampler args+  = let scalarArgs+          = catMaybes+              [("cudnn_off",) . showValue <$>+                 (args !? #cudnn_off :: Maybe (Maybe Bool))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("grid",) <$> (args !? #grid :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BilinearSampler"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_BilinearSampler_upd ::+                     forall args . Fullfilled "_BilinearSampler(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_BilinearSampler(ndarray)" args -> IO ()+_BilinearSampler_upd outputs args+  = let scalarArgs+          = catMaybes+              [("cudnn_off",) . showValue <$>+                 (args !? #cudnn_off :: Maybe (Maybe Bool))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("grid",) <$> (args !? #grid :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BilinearSampler"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_BilinearSampler(ndarray)" =+     '[]++_backward_BilinearSampler ::+                          forall args .+                            Fullfilled "_backward_BilinearSampler(ndarray)" args =>+                            ArgsHMap "_backward_BilinearSampler(ndarray)" args ->+                              IO [NDArrayHandle]+_backward_BilinearSampler args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BilinearSampler"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_BilinearSampler_upd ::+                              forall args .+                                Fullfilled "_backward_BilinearSampler(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_backward_BilinearSampler(ndarray)" args -> IO ()+_backward_BilinearSampler_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BilinearSampler"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_LeakyReLU(ndarray)" = '[]++_backward_LeakyReLU ::+                    forall args . Fullfilled "_backward_LeakyReLU(ndarray)" args =>+                      ArgsHMap "_backward_LeakyReLU(ndarray)" args -> IO [NDArrayHandle]+_backward_LeakyReLU args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LeakyReLU"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_LeakyReLU_upd ::+                        forall args . Fullfilled "_backward_LeakyReLU(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_backward_LeakyReLU(ndarray)" args -> IO ()+_backward_LeakyReLU_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LeakyReLU"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Crop(ndarray)" =+     '[ '("num_args", AttrReq Int), '("offset", AttrOpt [Int]),+        '("h_w", AttrOpt [Int]), '("center_crop", AttrOpt Bool),+        '("data", AttrOpt [NDArrayHandle])]++_Crop ::+      forall args . Fullfilled "_Crop(ndarray)" args =>+        ArgsHMap "_Crop(ndarray)" args -> IO [NDArrayHandle]+_Crop args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]),+               ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]),+               ("center_crop",) . showValue <$>+                 (args !? #center_crop :: Maybe Bool)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "Crop"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        Nothing+         return listndarr++_Crop_upd ::+          forall args . Fullfilled "_Crop(ndarray)" args =>+            [NDArrayHandle] -> ArgsHMap "_Crop(ndarray)" args -> IO ()+_Crop_upd outputs args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]),+               ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]),+               ("center_crop",) . showValue <$>+                 (args !? #center_crop :: Maybe Bool)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])+      in+      do op <- nnGetOpHandle "Crop"+         let scalarArgs'+               = if hasKey args #num_args then scalarArgs else+                   (,) "num_args" (showValue (length array)) : scalarArgs+         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Crop(ndarray)" = '[]++_backward_Crop ::+               forall args . Fullfilled "_backward_Crop(ndarray)" args =>+                 ArgsHMap "_backward_Crop(ndarray)" args -> IO [NDArrayHandle]+_backward_Crop args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Crop"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Crop_upd ::+                   forall args . Fullfilled "_backward_Crop(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_backward_Crop(ndarray)" args -> IO ()+_backward_Crop_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Crop"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_ROIPooling(ndarray)" =+     '[ '("pooled_size", AttrReq [Int]),+        '("spatial_scale", AttrReq Float),+        '("data", AttrOpt NDArrayHandle), '("rois", AttrOpt NDArrayHandle)]++_ROIPooling ::+            forall args . Fullfilled "_ROIPooling(ndarray)" args =>+              ArgsHMap "_ROIPooling(ndarray)" args -> IO [NDArrayHandle]+_ROIPooling args+  = let scalarArgs+          = catMaybes+              [("pooled_size",) . showValue <$>+                 (args !? #pooled_size :: Maybe [Int]),+               ("spatial_scale",) . showValue <$>+                 (args !? #spatial_scale :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ROIPooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_ROIPooling_upd ::+                forall args . Fullfilled "_ROIPooling(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_ROIPooling(ndarray)" args -> IO ()+_ROIPooling_upd outputs args+  = let scalarArgs+          = catMaybes+              [("pooled_size",) . showValue <$>+                 (args !? #pooled_size :: Maybe [Int]),+               ("spatial_scale",) . showValue <$>+                 (args !? #spatial_scale :: Maybe Float)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ROIPooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_ROIPooling(ndarray)" = '[]++_backward_ROIPooling ::+                     forall args . Fullfilled "_backward_ROIPooling(ndarray)" args =>+                       ArgsHMap "_backward_ROIPooling(ndarray)" args -> IO [NDArrayHandle]+_backward_ROIPooling args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_ROIPooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_ROIPooling_upd ::+                         forall args . Fullfilled "_backward_ROIPooling(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_ROIPooling(ndarray)" args -> IO ()+_backward_ROIPooling_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_ROIPooling"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_SequenceLast(ndarray)" =+     '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int),+        '("data", AttrOpt NDArrayHandle),+        '("sequence_length", AttrOpt NDArrayHandle)]++_SequenceLast ::+              forall args . Fullfilled "_SequenceLast(ndarray)" args =>+                ArgsHMap "_SequenceLast(ndarray)" args -> IO [NDArrayHandle]+_SequenceLast args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceLast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_SequenceLast_upd ::+                  forall args . Fullfilled "_SequenceLast(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_SequenceLast(ndarray)" args -> IO ()+_SequenceLast_upd outputs args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceLast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SequenceLast(ndarray)" = '[]++_backward_SequenceLast ::+                       forall args . Fullfilled "_backward_SequenceLast(ndarray)" args =>+                         ArgsHMap "_backward_SequenceLast(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_SequenceLast args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceLast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SequenceLast_upd ::+                           forall args . Fullfilled "_backward_SequenceLast(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_SequenceLast(ndarray)" args -> IO ()+_backward_SequenceLast_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceLast"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_CrossDeviceCopy(ndarray)" = '[]++_CrossDeviceCopy ::+                 forall args . Fullfilled "_CrossDeviceCopy(ndarray)" args =>+                   ArgsHMap "_CrossDeviceCopy(ndarray)" args -> IO [NDArrayHandle]+_CrossDeviceCopy args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_CrossDeviceCopy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_CrossDeviceCopy_upd ::+                     forall args . Fullfilled "_CrossDeviceCopy(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_CrossDeviceCopy(ndarray)" args -> IO ()+_CrossDeviceCopy_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_CrossDeviceCopy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward__CrossDeviceCopy(ndarray)" =+     '[]++_backward__CrossDeviceCopy ::+                           forall args .+                             Fullfilled "_backward__CrossDeviceCopy(ndarray)" args =>+                             ArgsHMap "_backward__CrossDeviceCopy(ndarray)" args ->+                               IO [NDArrayHandle]+_backward__CrossDeviceCopy args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__CrossDeviceCopy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward__CrossDeviceCopy_upd ::+                               forall args .+                                 Fullfilled "_backward__CrossDeviceCopy(ndarray)" args =>+                                 [NDArrayHandle] ->+                                   ArgsHMap "_backward__CrossDeviceCopy(ndarray)" args -> IO ()+_backward__CrossDeviceCopy_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__CrossDeviceCopy"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_SpatialTransformer(ndarray)" =+     '[ '("target_shape", AttrOpt [Int]),+        '("transform_type", AttrReq (EnumType '["affine"])),+        '("sampler_type", AttrReq (EnumType '["bilinear"])),+        '("cudnn_off", AttrOpt (Maybe Bool)),+        '("data", AttrOpt NDArrayHandle), '("loc", AttrOpt NDArrayHandle)]++_SpatialTransformer ::+                    forall args . Fullfilled "_SpatialTransformer(ndarray)" args =>+                      ArgsHMap "_SpatialTransformer(ndarray)" args -> IO [NDArrayHandle]+_SpatialTransformer args+  = let scalarArgs+          = catMaybes+              [("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("transform_type",) . showValue <$>+                 (args !? #transform_type :: Maybe (EnumType '["affine"])),+               ("sampler_type",) . showValue <$>+                 (args !? #sampler_type :: Maybe (EnumType '["bilinear"])),+               ("cudnn_off",) . showValue <$>+                 (args !? #cudnn_off :: Maybe (Maybe Bool))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("loc",) <$> (args !? #loc :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SpatialTransformer"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_SpatialTransformer_upd ::+                        forall args . Fullfilled "_SpatialTransformer(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "_SpatialTransformer(ndarray)" args -> IO ()+_SpatialTransformer_upd outputs args+  = let scalarArgs+          = catMaybes+              [("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("transform_type",) . showValue <$>+                 (args !? #transform_type :: Maybe (EnumType '["affine"])),+               ("sampler_type",) . showValue <$>+                 (args !? #sampler_type :: Maybe (EnumType '["bilinear"])),+               ("cudnn_off",) . showValue <$>+                 (args !? #cudnn_off :: Maybe (Maybe Bool))]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("loc",) <$> (args !? #loc :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SpatialTransformer"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SpatialTransformer(ndarray)"+     = '[]++_backward_SpatialTransformer ::+                             forall args .+                               Fullfilled "_backward_SpatialTransformer(ndarray)" args =>+                               ArgsHMap "_backward_SpatialTransformer(ndarray)" args ->+                                 IO [NDArrayHandle]+_backward_SpatialTransformer args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SpatialTransformer"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SpatialTransformer_upd ::+                                 forall args .+                                   Fullfilled "_backward_SpatialTransformer(ndarray)" args =>+                                   [NDArrayHandle] ->+                                     ArgsHMap "_backward_SpatialTransformer(ndarray)" args -> IO ()+_backward_SpatialTransformer_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SpatialTransformer"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SwapAxis(ndarray)" = '[]++_backward_SwapAxis ::+                   forall args . Fullfilled "_backward_SwapAxis(ndarray)" args =>+                     ArgsHMap "_backward_SwapAxis(ndarray)" args -> IO [NDArrayHandle]+_backward_SwapAxis args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SwapAxis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SwapAxis_upd ::+                       forall args . Fullfilled "_backward_SwapAxis(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_backward_SwapAxis(ndarray)" args -> IO ()+_backward_SwapAxis_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SwapAxis"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_L2Normalization(ndarray)" =+     '[ '("eps", AttrOpt Float),+        '("mode", AttrOpt (EnumType '["channel", "instance", "spatial"])),+        '("data", AttrOpt NDArrayHandle)]++_L2Normalization ::+                 forall args . Fullfilled "_L2Normalization(ndarray)" args =>+                   ArgsHMap "_L2Normalization(ndarray)" args -> IO [NDArrayHandle]+_L2Normalization args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["channel", "instance", "spatial"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "L2Normalization"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_L2Normalization_upd ::+                     forall args . Fullfilled "_L2Normalization(ndarray)" args =>+                       [NDArrayHandle] ->+                         ArgsHMap "_L2Normalization(ndarray)" args -> IO ()+_L2Normalization_upd outputs args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["channel", "instance", "spatial"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "L2Normalization"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_L2Normalization(ndarray)" =+     '[]++_backward_L2Normalization ::+                          forall args .+                            Fullfilled "_backward_L2Normalization(ndarray)" args =>+                            ArgsHMap "_backward_L2Normalization(ndarray)" args ->+                              IO [NDArrayHandle]+_backward_L2Normalization args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_L2Normalization"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_L2Normalization_upd ::+                              forall args .+                                Fullfilled "_backward_L2Normalization(ndarray)" args =>+                                [NDArrayHandle] ->+                                  ArgsHMap "_backward_L2Normalization(ndarray)" args -> IO ()+_backward_L2Normalization_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_L2Normalization"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Correlation(ndarray)" =+     '[ '("kernel_size", AttrOpt Int),+        '("max_displacement", AttrOpt Int), '("stride1", AttrOpt Int),+        '("stride2", AttrOpt Int), '("pad_size", AttrOpt Int),+        '("is_multiply", AttrOpt Bool), '("data1", AttrOpt NDArrayHandle),+        '("data2", AttrOpt NDArrayHandle)]++_Correlation ::+             forall args . Fullfilled "_Correlation(ndarray)" args =>+               ArgsHMap "_Correlation(ndarray)" args -> IO [NDArrayHandle]+_Correlation args+  = let scalarArgs+          = catMaybes+              [("kernel_size",) . showValue <$>+                 (args !? #kernel_size :: Maybe Int),+               ("max_displacement",) . showValue <$>+                 (args !? #max_displacement :: Maybe Int),+               ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int),+               ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int),+               ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int),+               ("is_multiply",) . showValue <$>+                 (args !? #is_multiply :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data1",) <$> (args !? #data1 :: Maybe NDArrayHandle),+               ("data2",) <$> (args !? #data2 :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Correlation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Correlation_upd ::+                 forall args . Fullfilled "_Correlation(ndarray)" args =>+                   [NDArrayHandle] -> ArgsHMap "_Correlation(ndarray)" args -> IO ()+_Correlation_upd outputs args+  = let scalarArgs+          = catMaybes+              [("kernel_size",) . showValue <$>+                 (args !? #kernel_size :: Maybe Int),+               ("max_displacement",) . showValue <$>+                 (args !? #max_displacement :: Maybe Int),+               ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int),+               ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int),+               ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int),+               ("is_multiply",) . showValue <$>+                 (args !? #is_multiply :: Maybe Bool)]+        tensorArgs+          = catMaybes+              [("data1",) <$> (args !? #data1 :: Maybe NDArrayHandle),+               ("data2",) <$> (args !? #data2 :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Correlation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Correlation(ndarray)" = '[]++_backward_Correlation ::+                      forall args . Fullfilled "_backward_Correlation(ndarray)" args =>+                        ArgsHMap "_backward_Correlation(ndarray)" args ->+                          IO [NDArrayHandle]+_backward_Correlation args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Correlation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Correlation_upd ::+                          forall args . Fullfilled "_backward_Correlation(ndarray)" args =>+                            [NDArrayHandle] ->+                              ArgsHMap "_backward_Correlation(ndarray)" args -> IO ()+_backward_Correlation_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Correlation"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance+     ParameterList "_backward_IdentityAttachKLSparseReg(ndarray)" = '[]++_backward_IdentityAttachKLSparseReg ::+                                    forall args .+                                      Fullfilled "_backward_IdentityAttachKLSparseReg(ndarray)"+                                        args =>+                                      ArgsHMap "_backward_IdentityAttachKLSparseReg(ndarray)" args+                                        -> IO [NDArrayHandle]+_backward_IdentityAttachKLSparseReg args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_IdentityAttachKLSparseReg_upd ::+                                        forall args .+                                          Fullfilled "_backward_IdentityAttachKLSparseReg(ndarray)"+                                            args =>+                                          [NDArrayHandle] ->+                                            ArgsHMap "_backward_IdentityAttachKLSparseReg(ndarray)"+                                              args+                                              -> IO ()+_backward_IdentityAttachKLSparseReg_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_MakeLoss(ndarray)" =+     '[ '("grad_scale", AttrOpt Float),+        '("valid_thresh", AttrOpt Float),+        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),+        '("data", AttrOpt NDArrayHandle)]++_MakeLoss ::+          forall args . Fullfilled "_MakeLoss(ndarray)" args =>+            ArgsHMap "_MakeLoss(ndarray)" args -> IO [NDArrayHandle]+_MakeLoss args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float),+               ("valid_thresh",) . showValue <$>+                 (args !? #valid_thresh :: Maybe Float),+               ("normalization",) . showValue <$>+                 (args !? #normalization ::+                    Maybe (EnumType '["batch", "null", "valid"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "MakeLoss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_MakeLoss_upd ::+              forall args . Fullfilled "_MakeLoss(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "_MakeLoss(ndarray)" args -> IO ()+_MakeLoss_upd outputs args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float),+               ("valid_thresh",) . showValue <$>+                 (args !? #valid_thresh :: Maybe Float),+               ("normalization",) . showValue <$>+                 (args !? #normalization ::+                    Maybe (EnumType '["batch", "null", "valid"]))]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "MakeLoss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_MakeLoss(ndarray)" = '[]++_backward_MakeLoss ::+                   forall args . Fullfilled "_backward_MakeLoss(ndarray)" args =>+                     ArgsHMap "_backward_MakeLoss(ndarray)" args -> IO [NDArrayHandle]+_backward_MakeLoss args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_MakeLoss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_MakeLoss_upd ::+                       forall args . Fullfilled "_backward_MakeLoss(ndarray)" args =>+                         [NDArrayHandle] ->+                           ArgsHMap "_backward_MakeLoss(ndarray)" args -> IO ()+_backward_MakeLoss_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_MakeLoss"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SliceChannel(ndarray)" = '[]++_backward_SliceChannel ::+                       forall args . Fullfilled "_backward_SliceChannel(ndarray)" args =>+                         ArgsHMap "_backward_SliceChannel(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_SliceChannel args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SliceChannel"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SliceChannel_upd ::+                           forall args . Fullfilled "_backward_SliceChannel(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_SliceChannel(ndarray)" args -> IO ()+_backward_SliceChannel_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SliceChannel"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_Pooling_v1(ndarray)" =+     '[ '("kernel", AttrOpt [Int]),+        '("pool_type", AttrOpt (EnumType '["avg", "max", "sum"])),+        '("global_pool", AttrOpt Bool),+        '("pooling_convention", AttrOpt (EnumType '["full", "valid"])),+        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("data", AttrOpt NDArrayHandle)]++_Pooling_v1 ::+            forall args . Fullfilled "_Pooling_v1(ndarray)" args =>+              ArgsHMap "_Pooling_v1(ndarray)" args -> IO [NDArrayHandle]+_Pooling_v1 args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("pool_type",) . showValue <$>+                 (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])),+               ("global_pool",) . showValue <$>+                 (args !? #global_pool :: Maybe Bool),+               ("pooling_convention",) . showValue <$>+                 (args !? #pooling_convention ::+                    Maybe (EnumType '["full", "valid"])),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pooling_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_Pooling_v1_upd ::+                forall args . Fullfilled "_Pooling_v1(ndarray)" args =>+                  [NDArrayHandle] -> ArgsHMap "_Pooling_v1(ndarray)" args -> IO ()+_Pooling_v1_upd outputs args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("pool_type",) . showValue <$>+                 (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])),+               ("global_pool",) . showValue <$>+                 (args !? #global_pool :: Maybe Bool),+               ("pooling_convention",) . showValue <$>+                 (args !? #pooling_convention ::+                    Maybe (EnumType '["full", "valid"])),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])]+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pooling_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Pooling_v1(ndarray)" = '[]++_backward_Pooling_v1 ::+                     forall args . Fullfilled "_backward_Pooling_v1(ndarray)" args =>+                       ArgsHMap "_backward_Pooling_v1(ndarray)" args -> IO [NDArrayHandle]+_backward_Pooling_v1 args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pooling_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Pooling_v1_upd ::+                         forall args . Fullfilled "_backward_Pooling_v1(ndarray)" args =>+                           [NDArrayHandle] ->+                             ArgsHMap "_backward_Pooling_v1(ndarray)" args -> IO ()+_backward_Pooling_v1_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pooling_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_Pad(ndarray)" = '[]++_backward_Pad ::+              forall args . Fullfilled "_backward_Pad(ndarray)" args =>+                ArgsHMap "_backward_Pad(ndarray)" args -> IO [NDArrayHandle]+_backward_Pad args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pad"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_Pad_upd ::+                  forall args . Fullfilled "_backward_Pad(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_backward_Pad(ndarray)" args -> IO ()+_backward_Pad_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pad"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_BatchNorm_v1(ndarray)" = '[]++_backward_BatchNorm_v1 ::+                       forall args . Fullfilled "_backward_BatchNorm_v1(ndarray)" args =>+                         ArgsHMap "_backward_BatchNorm_v1(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_BatchNorm_v1 args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BatchNorm_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_BatchNorm_v1_upd ::+                           forall args . Fullfilled "_backward_BatchNorm_v1(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_BatchNorm_v1(ndarray)" args -> IO ()+_backward_BatchNorm_v1_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BatchNorm_v1"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_SequenceMask(ndarray)" =+     '[ '("use_sequence_length", AttrOpt Bool),+        '("value", AttrOpt Float), '("axis", AttrOpt Int),+        '("data", AttrOpt NDArrayHandle),+        '("sequence_length", AttrOpt NDArrayHandle)]++_SequenceMask ::+              forall args . Fullfilled "_SequenceMask(ndarray)" args =>+                ArgsHMap "_SequenceMask(ndarray)" args -> IO [NDArrayHandle]+_SequenceMask args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool),+               ("value",) . showValue <$> (args !? #value :: Maybe Float),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceMask"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_SequenceMask_upd ::+                  forall args . Fullfilled "_SequenceMask(ndarray)" args =>+                    [NDArrayHandle] -> ArgsHMap "_SequenceMask(ndarray)" args -> IO ()+_SequenceMask_upd outputs args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool),+               ("value",) . showValue <$> (args !? #value :: Maybe Float),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceMask"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_backward_SequenceMask(ndarray)" = '[]++_backward_SequenceMask ::+                       forall args . Fullfilled "_backward_SequenceMask(ndarray)" args =>+                         ArgsHMap "_backward_SequenceMask(ndarray)" args ->+                           IO [NDArrayHandle]+_backward_SequenceMask args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceMask"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_backward_SequenceMask_upd ::+                           forall args . Fullfilled "_backward_SequenceMask(ndarray)" args =>+                             [NDArrayHandle] ->+                               ArgsHMap "_backward_SequenceMask(ndarray)" args -> IO ()+_backward_SequenceMask_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceMask"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_set_value(ndarray)" =+     '[ '("src", AttrOpt Float)]++_set_value ::+           forall args . Fullfilled "_set_value(ndarray)" args =>+             ArgsHMap "_set_value(ndarray)" args -> IO [NDArrayHandle]+_set_value args+  = let scalarArgs+          = catMaybes+              [("src",) . showValue <$> (args !? #src :: Maybe Float)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_set_value"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_set_value_upd ::+               forall args . Fullfilled "_set_value(ndarray)" args =>+                 [NDArrayHandle] -> ArgsHMap "_set_value(ndarray)" args -> IO ()+_set_value_upd outputs args+  = let scalarArgs+          = catMaybes+              [("src",) . showValue <$> (args !? #src :: Maybe Float)]+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_set_value"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_onehot_encode(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("rhs", AttrOpt NDArrayHandle)]++_onehot_encode ::+               forall args . Fullfilled "_onehot_encode(ndarray)" args =>+                 ArgsHMap "_onehot_encode(ndarray)" args -> IO [NDArrayHandle]+_onehot_encode args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_onehot_encode"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_onehot_encode_upd ::+                   forall args . Fullfilled "_onehot_encode(ndarray)" args =>+                     [NDArrayHandle] -> ArgsHMap "_onehot_encode(ndarray)" args -> IO ()+_onehot_encode_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_onehot_encode"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "fill_element_0index(ndarray)" =+     '[ '("lhs", AttrOpt NDArrayHandle),+        '("mhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]++fill_element_0index ::+                    forall args . Fullfilled "fill_element_0index(ndarray)" args =>+                      ArgsHMap "fill_element_0index(ndarray)" args -> IO [NDArrayHandle]+fill_element_0index args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("mhs",) <$> (args !? #mhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "fill_element_0index"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++fill_element_0index_upd ::+                        forall args . Fullfilled "fill_element_0index(ndarray)" args =>+                          [NDArrayHandle] ->+                            ArgsHMap "fill_element_0index(ndarray)" args -> IO ()+fill_element_0index_upd outputs args+  = let scalarArgs = catMaybes []+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),+               ("mhs",) <$> (args !? #mhs :: Maybe NDArrayHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "fill_element_0index"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()++type instance ParameterList "_imdecode(ndarray)" =+     '[ '("index", AttrOpt Int), '("x0", AttrOpt Int),+        '("y0", AttrOpt Int), '("x1", AttrOpt Int), '("y1", AttrOpt Int),+        '("c", AttrOpt Int), '("size", AttrOpt Int),+        '("mean", AttrOpt NDArrayHandle)]++_imdecode ::+          forall args . Fullfilled "_imdecode(ndarray)" args =>+            ArgsHMap "_imdecode(ndarray)" args -> IO [NDArrayHandle]+_imdecode args+  = let scalarArgs+          = catMaybes+              [("index",) . showValue <$> (args !? #index :: Maybe Int),+               ("x0",) . showValue <$> (args !? #x0 :: Maybe Int),+               ("y0",) . showValue <$> (args !? #y0 :: Maybe Int),+               ("x1",) . showValue <$> (args !? #x1 :: Maybe Int),+               ("y1",) . showValue <$> (args !? #y1 :: Maybe Int),+               ("c",) . showValue <$> (args !? #c :: Maybe Int),+               ("size",) . showValue <$> (args !? #size :: Maybe Int)]+        tensorArgs+          = catMaybes [("mean",) <$> (args !? #mean :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_imdecode"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        Nothing+         return listndarr++_imdecode_upd ::+              forall args . Fullfilled "_imdecode(ndarray)" args =>+                [NDArrayHandle] -> ArgsHMap "_imdecode(ndarray)" args -> IO ()+_imdecode_upd outputs args+  = let scalarArgs+          = catMaybes+              [("index",) . showValue <$> (args !? #index :: Maybe Int),+               ("x0",) . showValue <$> (args !? #x0 :: Maybe Int),+               ("y0",) . showValue <$> (args !? #y0 :: Maybe Int),+               ("x1",) . showValue <$> (args !? #x1 :: Maybe Int),+               ("y1",) . showValue <$> (args !? #y1 :: Maybe Int),+               ("c",) . showValue <$> (args !? #c :: Maybe Int),+               ("size",) . showValue <$> (args !? #size :: Maybe Int)]+        tensorArgs+          = catMaybes [("mean",) <$> (args !? #mean :: Maybe NDArrayHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_imdecode"+         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals+                        scalarArgs+                        (Just outputs)+         return ()
+ ops/1.5/MXNet/Base/Operators/Symbol.hs view
@@ -0,0 +1,13179 @@+module MXNet.Base.Operators.Symbol where+import MXNet.Base.Raw+import MXNet.Base.Spec.Operator+import MXNet.Base.Spec.HMap+import Data.Maybe (catMaybes, fromMaybe)++type instance ParameterList "_CuDNNBatchNorm(symbol)" =+     '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float),+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),+        '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int),+        '("cudnn_off", AttrOpt Bool), '("data", AttrOpt SymbolHandle),+        '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle),+        '("moving_mean", AttrOpt SymbolHandle),+        '("moving_var", AttrOpt SymbolHandle)]++_CuDNNBatchNorm ::+                forall args . Fullfilled "_CuDNNBatchNorm(symbol)" args =>+                  String ->+                    ArgsHMap "_CuDNNBatchNorm(symbol)" args -> IO SymbolHandle+_CuDNNBatchNorm name args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),+               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle),+               ("moving_mean",) <$> (args !? #moving_mean :: Maybe SymbolHandle),+               ("moving_var",) <$> (args !? #moving_var :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "CuDNNBatchNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_CuDNNBatchNorm(symbol)" =+     '[]++_backward_CuDNNBatchNorm ::+                         forall args . Fullfilled "_backward_CuDNNBatchNorm(symbol)" args =>+                           String ->+                             ArgsHMap "_backward_CuDNNBatchNorm(symbol)" args -> IO SymbolHandle+_backward_CuDNNBatchNorm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_CuDNNBatchNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_multinomial(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("get_prob", AttrOpt Bool),+        '("dtype",+          AttrOpt+            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),+        '("data", AttrOpt SymbolHandle)]++_sample_multinomial ::+                    forall args . Fullfilled "_sample_multinomial(symbol)" args =>+                      String ->+                        ArgsHMap "_sample_multinomial(symbol)" args -> IO SymbolHandle+_sample_multinomial name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_multinomial"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sample_multinomial(symbol)"+     = '[]++_backward_sample_multinomial ::+                             forall args .+                               Fullfilled "_backward_sample_multinomial(symbol)" args =>+                               String ->+                                 ArgsHMap "_backward_sample_multinomial(symbol)" args ->+                                   IO SymbolHandle+_backward_sample_multinomial name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sample_multinomial"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_uniform(symbol)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("low", AttrOpt SymbolHandle), '("high", AttrOpt SymbolHandle)]++_sample_uniform ::+                forall args . Fullfilled "_sample_uniform(symbol)" args =>+                  String ->+                    ArgsHMap "_sample_uniform(symbol)" args -> IO SymbolHandle+_sample_uniform name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("low",) <$> (args !? #low :: Maybe SymbolHandle),+               ("high",) <$> (args !? #high :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_uniform"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_normal(symbol)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("mu", AttrOpt SymbolHandle), '("sigma", AttrOpt SymbolHandle)]++_sample_normal ::+               forall args . Fullfilled "_sample_normal(symbol)" args =>+                 String -> ArgsHMap "_sample_normal(symbol)" args -> IO SymbolHandle+_sample_normal name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("mu",) <$> (args !? #mu :: Maybe SymbolHandle),+               ("sigma",) <$> (args !? #sigma :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_normal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_gamma(symbol)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("alpha", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle)]++_sample_gamma ::+              forall args . Fullfilled "_sample_gamma(symbol)" args =>+                String -> ArgsHMap "_sample_gamma(symbol)" args -> IO SymbolHandle+_sample_gamma name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("alpha",) <$> (args !? #alpha :: Maybe SymbolHandle),+               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_gamma"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_exponential(symbol)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("lam", AttrOpt SymbolHandle)]++_sample_exponential ::+                    forall args . Fullfilled "_sample_exponential(symbol)" args =>+                      String ->+                        ArgsHMap "_sample_exponential(symbol)" args -> IO SymbolHandle+_sample_exponential name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("lam",) <$> (args !? #lam :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_exponential"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_poisson(symbol)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("lam", AttrOpt SymbolHandle)]++_sample_poisson ::+                forall args . Fullfilled "_sample_poisson(symbol)" args =>+                  String ->+                    ArgsHMap "_sample_poisson(symbol)" args -> IO SymbolHandle+_sample_poisson name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("lam",) <$> (args !? #lam :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_poisson"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_negative_binomial(symbol)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("k", AttrOpt SymbolHandle), '("p", AttrOpt SymbolHandle)]++_sample_negative_binomial ::+                          forall args .+                            Fullfilled "_sample_negative_binomial(symbol)" args =>+                            String ->+                              ArgsHMap "_sample_negative_binomial(symbol)" args ->+                                IO SymbolHandle+_sample_negative_binomial name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("k",) <$> (args !? #k :: Maybe SymbolHandle),+               ("p",) <$> (args !? #p :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_negative_binomial"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_sample_generalized_negative_binomial(symbol)" =+     '[ '("shape", AttrOpt [Int]),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),+        '("mu", AttrOpt SymbolHandle), '("alpha", AttrOpt SymbolHandle)]++_sample_generalized_negative_binomial ::+                                      forall args .+                                        Fullfilled "_sample_generalized_negative_binomial(symbol)"+                                          args =>+                                        String ->+                                          ArgsHMap "_sample_generalized_negative_binomial(symbol)"+                                            args+                                            -> IO SymbolHandle+_sample_generalized_negative_binomial name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("mu",) <$> (args !? #mu :: Maybe SymbolHandle),+               ("alpha",) <$> (args !? #alpha :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_generalized_negative_binomial"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sample_unique_zipfian(symbol)" =+     '[ '("range_max", AttrReq Int), '("shape", AttrOpt [Int])]++_sample_unique_zipfian ::+                       forall args . Fullfilled "_sample_unique_zipfian(symbol)" args =>+                         String ->+                           ArgsHMap "_sample_unique_zipfian(symbol)" args -> IO SymbolHandle+_sample_unique_zipfian name args+  = let scalarArgs+          = catMaybes+              [("range_max",) . showValue <$> (args !? #range_max :: Maybe Int),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sample_unique_zipfian"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_uniform(symbol)" =+     '[ '("low", AttrOpt Float), '("high", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_uniform ::+                forall args . Fullfilled "_random_uniform(symbol)" args =>+                  String ->+                    ArgsHMap "_random_uniform(symbol)" args -> IO SymbolHandle+_random_uniform name args+  = let scalarArgs+          = catMaybes+              [("low",) . showValue <$> (args !? #low :: Maybe Float),+               ("high",) . showValue <$> (args !? #high :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_uniform"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_normal(symbol)" =+     '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_normal ::+               forall args . Fullfilled "_random_normal(symbol)" args =>+                 String -> ArgsHMap "_random_normal(symbol)" args -> IO SymbolHandle+_random_normal name args+  = let scalarArgs+          = catMaybes+              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),+               ("scale",) . showValue <$> (args !? #scale :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_normal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_gamma(symbol)" =+     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_gamma ::+              forall args . Fullfilled "_random_gamma(symbol)" args =>+                String -> ArgsHMap "_random_gamma(symbol)" args -> IO SymbolHandle+_random_gamma name args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_gamma"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_exponential(symbol)" =+     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),+        '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_exponential ::+                    forall args . Fullfilled "_random_exponential(symbol)" args =>+                      String ->+                        ArgsHMap "_random_exponential(symbol)" args -> IO SymbolHandle+_random_exponential name args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_exponential"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_poisson(symbol)" =+     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),+        '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_poisson ::+                forall args . Fullfilled "_random_poisson(symbol)" args =>+                  String ->+                    ArgsHMap "_random_poisson(symbol)" args -> IO SymbolHandle+_random_poisson name args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_poisson"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_negative_binomial(symbol)" =+     '[ '("k", AttrOpt Int), '("p", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_negative_binomial ::+                          forall args .+                            Fullfilled "_random_negative_binomial(symbol)" args =>+                            String ->+                              ArgsHMap "_random_negative_binomial(symbol)" args ->+                                IO SymbolHandle+_random_negative_binomial name args+  = let scalarArgs+          = catMaybes+              [("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_negative_binomial"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_random_generalized_negative_binomial(symbol)" =+     '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]++_random_generalized_negative_binomial ::+                                      forall args .+                                        Fullfilled "_random_generalized_negative_binomial(symbol)"+                                          args =>+                                        String ->+                                          ArgsHMap "_random_generalized_negative_binomial(symbol)"+                                            args+                                            -> IO SymbolHandle+_random_generalized_negative_binomial name args+  = let scalarArgs+          = catMaybes+              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_generalized_negative_binomial"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_randint(symbol)" =+     '[ '("low", AttrReq Int), '("high", AttrReq Int),+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype", AttrOpt (EnumType '["None", "int32", "int64"]))]++_random_randint ::+                forall args . Fullfilled "_random_randint(symbol)" args =>+                  String ->+                    ArgsHMap "_random_randint(symbol)" args -> IO SymbolHandle+_random_randint name args+  = let scalarArgs+          = catMaybes+              [("low",) . showValue <$> (args !? #low :: Maybe Int),+               ("high",) . showValue <$> (args !? #high :: Maybe Int),+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype :: Maybe (EnumType '["None", "int32", "int64"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_randint"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_uniform_like(symbol)" =+     '[ '("low", AttrOpt Float), '("high", AttrOpt Float),+        '("data", AttrOpt SymbolHandle)]++_random_uniform_like ::+                     forall args . Fullfilled "_random_uniform_like(symbol)" args =>+                       String ->+                         ArgsHMap "_random_uniform_like(symbol)" args -> IO SymbolHandle+_random_uniform_like name args+  = let scalarArgs+          = catMaybes+              [("low",) . showValue <$> (args !? #low :: Maybe Float),+               ("high",) . showValue <$> (args !? #high :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_uniform_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_normal_like(symbol)" =+     '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float),+        '("data", AttrOpt SymbolHandle)]++_random_normal_like ::+                    forall args . Fullfilled "_random_normal_like(symbol)" args =>+                      String ->+                        ArgsHMap "_random_normal_like(symbol)" args -> IO SymbolHandle+_random_normal_like name args+  = let scalarArgs+          = catMaybes+              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),+               ("scale",) . showValue <$> (args !? #scale :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_normal_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_gamma_like(symbol)" =+     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),+        '("data", AttrOpt SymbolHandle)]++_random_gamma_like ::+                   forall args . Fullfilled "_random_gamma_like(symbol)" args =>+                     String ->+                       ArgsHMap "_random_gamma_like(symbol)" args -> IO SymbolHandle+_random_gamma_like name args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_gamma_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_exponential_like(symbol)" =+     '[ '("lam", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_random_exponential_like ::+                         forall args . Fullfilled "_random_exponential_like(symbol)" args =>+                           String ->+                             ArgsHMap "_random_exponential_like(symbol)" args -> IO SymbolHandle+_random_exponential_like name args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_exponential_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_random_poisson_like(symbol)" =+     '[ '("lam", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_random_poisson_like ::+                     forall args . Fullfilled "_random_poisson_like(symbol)" args =>+                       String ->+                         ArgsHMap "_random_poisson_like(symbol)" args -> IO SymbolHandle+_random_poisson_like name args+  = let scalarArgs+          = catMaybes+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_poisson_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_random_negative_binomial_like(symbol)" =+     '[ '("k", AttrOpt Int), '("p", AttrOpt Float),+        '("data", AttrOpt SymbolHandle)]++_random_negative_binomial_like ::+                               forall args .+                                 Fullfilled "_random_negative_binomial_like(symbol)" args =>+                                 String ->+                                   ArgsHMap "_random_negative_binomial_like(symbol)" args ->+                                     IO SymbolHandle+_random_negative_binomial_like name args+  = let scalarArgs+          = catMaybes+              [("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("p",) . showValue <$> (args !? #p :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_negative_binomial_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_random_generalized_negative_binomial_like(symbol)"+     =+     '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float),+        '("data", AttrOpt SymbolHandle)]++_random_generalized_negative_binomial_like ::+                                           forall args .+                                             Fullfilled+                                               "_random_generalized_negative_binomial_like(symbol)"+                                               args =>+                                             String ->+                                               ArgsHMap+                                                 "_random_generalized_negative_binomial_like(symbol)"+                                                 args+                                                 -> IO SymbolHandle+_random_generalized_negative_binomial_like name args+  = let scalarArgs+          = catMaybes+              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_random_generalized_negative_binomial_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_shuffle(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++_shuffle ::+         forall args . Fullfilled "_shuffle(symbol)" args =>+           String -> ArgsHMap "_shuffle(symbol)" args -> IO SymbolHandle+_shuffle name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_shuffle"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Custom(symbol)" =+     '[ '("op_type", AttrOpt String), '("data", AttrOpt [SymbolHandle])]++_Custom ::+        forall args .+          (Fullfilled "_Custom(symbol)" args,+           PopKey (ArgOf "_Custom(symbol)") args "data",+           Dump (PopResult (ArgOf "_Custom(symbol)") args "data")) =>+          String -> ArgsHMap "_Custom(symbol)" args -> IO SymbolHandle+_Custom name args+  = let scalarArgs = dump (pop args #data)+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "Custom"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_backward_Custom(symbol)" = '[]++_backward_Custom ::+                 forall args . Fullfilled "_backward_Custom(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_Custom(symbol)" args -> IO SymbolHandle+_backward_Custom name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Custom"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_power(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_power ::+                forall args . Fullfilled "broadcast_power(symbol)" args =>+                  String ->+                    ArgsHMap "broadcast_power(symbol)" args -> IO SymbolHandle+broadcast_power name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_power"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_power(symbol)" =+     '[]++_backward_broadcast_power ::+                          forall args .+                            Fullfilled "_backward_broadcast_power(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_broadcast_power(symbol)" args ->+                                IO SymbolHandle+_backward_broadcast_power name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_power"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_maximum(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_maximum ::+                  forall args . Fullfilled "broadcast_maximum(symbol)" args =>+                    String ->+                      ArgsHMap "broadcast_maximum(symbol)" args -> IO SymbolHandle+broadcast_maximum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_maximum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_maximum(symbol)" =+     '[]++_backward_broadcast_maximum ::+                            forall args .+                              Fullfilled "_backward_broadcast_maximum(symbol)" args =>+                              String ->+                                ArgsHMap "_backward_broadcast_maximum(symbol)" args ->+                                  IO SymbolHandle+_backward_broadcast_maximum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_maximum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_minimum(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_minimum ::+                  forall args . Fullfilled "broadcast_minimum(symbol)" args =>+                    String ->+                      ArgsHMap "broadcast_minimum(symbol)" args -> IO SymbolHandle+broadcast_minimum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_minimum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_minimum(symbol)" =+     '[]++_backward_broadcast_minimum ::+                            forall args .+                              Fullfilled "_backward_broadcast_minimum(symbol)" args =>+                              String ->+                                ArgsHMap "_backward_broadcast_minimum(symbol)" args ->+                                  IO SymbolHandle+_backward_broadcast_minimum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_minimum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_hypot(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_hypot ::+                forall args . Fullfilled "broadcast_hypot(symbol)" args =>+                  String ->+                    ArgsHMap "broadcast_hypot(symbol)" args -> IO SymbolHandle+broadcast_hypot name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_hypot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_hypot(symbol)" =+     '[]++_backward_broadcast_hypot ::+                          forall args .+                            Fullfilled "_backward_broadcast_hypot(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_broadcast_hypot(symbol)" args ->+                                IO SymbolHandle+_backward_broadcast_hypot name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_hypot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_equal ::+       forall args . Fullfilled "_equal(symbol)" args =>+         String -> ArgsHMap "_equal(symbol)" args -> IO SymbolHandle+_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_not_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_not_equal ::+           forall args . Fullfilled "_not_equal(symbol)" args =>+             String -> ArgsHMap "_not_equal(symbol)" args -> IO SymbolHandle+_not_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_not_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_greater(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_greater ::+         forall args . Fullfilled "_greater(symbol)" args =>+           String -> ArgsHMap "_greater(symbol)" args -> IO SymbolHandle+_greater name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_greater_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_greater_equal ::+               forall args . Fullfilled "_greater_equal(symbol)" args =>+                 String -> ArgsHMap "_greater_equal(symbol)" args -> IO SymbolHandle+_greater_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_lesser(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_lesser ::+        forall args . Fullfilled "_lesser(symbol)" args =>+          String -> ArgsHMap "_lesser(symbol)" args -> IO SymbolHandle+_lesser name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_lesser_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_lesser_equal ::+              forall args . Fullfilled "_lesser_equal(symbol)" args =>+                String -> ArgsHMap "_lesser_equal(symbol)" args -> IO SymbolHandle+_lesser_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_logical_and(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_logical_and ::+             forall args . Fullfilled "_logical_and(symbol)" args =>+               String -> ArgsHMap "_logical_and(symbol)" args -> IO SymbolHandle+_logical_and name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_and"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_logical_or(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_logical_or ::+            forall args . Fullfilled "_logical_or(symbol)" args =>+              String -> ArgsHMap "_logical_or(symbol)" args -> IO SymbolHandle+_logical_or name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_or"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_logical_xor(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_logical_xor ::+             forall args . Fullfilled "_logical_xor(symbol)" args =>+               String -> ArgsHMap "_logical_xor(symbol)" args -> IO SymbolHandle+_logical_xor name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_xor"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_power(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_power ::+       forall args . Fullfilled "_power(symbol)" args =>+         String -> ArgsHMap "_power(symbol)" args -> IO SymbolHandle+_power name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_power"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_power(symbol)" = '[]++_backward_power ::+                forall args . Fullfilled "_backward_power(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_power(symbol)" args -> IO SymbolHandle+_backward_power name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_power"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_maximum(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_maximum ::+         forall args . Fullfilled "_maximum(symbol)" args =>+           String -> ArgsHMap "_maximum(symbol)" args -> IO SymbolHandle+_maximum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_maximum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_maximum(symbol)" = '[]++_backward_maximum ::+                  forall args . Fullfilled "_backward_maximum(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_maximum(symbol)" args -> IO SymbolHandle+_backward_maximum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_maximum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_minimum(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_minimum ::+         forall args . Fullfilled "_minimum(symbol)" args =>+           String -> ArgsHMap "_minimum(symbol)" args -> IO SymbolHandle+_minimum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minimum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_minimum(symbol)" = '[]++_backward_minimum ::+                  forall args . Fullfilled "_backward_minimum(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_minimum(symbol)" args -> IO SymbolHandle+_backward_minimum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_minimum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_hypot(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_hypot ::+       forall args . Fullfilled "_hypot(symbol)" args =>+         String -> ArgsHMap "_hypot(symbol)" args -> IO SymbolHandle+_hypot name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_hypot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_hypot(symbol)" = '[]++_backward_hypot ::+                forall args . Fullfilled "_backward_hypot(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_hypot(symbol)" args -> IO SymbolHandle+_backward_hypot name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_hypot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_square_sum(symbol)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++_square_sum ::+            forall args . Fullfilled "_square_sum(symbol)" args =>+              String -> ArgsHMap "_square_sum(symbol)" args -> IO SymbolHandle+_square_sum name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_square_sum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_square_sum(symbol)" = '[]++_backward_square_sum ::+                     forall args . Fullfilled "_backward_square_sum(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_square_sum(symbol)" args -> IO SymbolHandle+_backward_square_sum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_square_sum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "add_n(symbol)" =+     '[ '("args", AttrOpt [SymbolHandle])]++add_n ::+      forall args . Fullfilled "add_n(symbol)" args =>+        String -> ArgsHMap "add_n(symbol)" args -> IO SymbolHandle+add_n name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "add_n"+         sym <- if hasKey args #num_args then+                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals+                  else+                  mxSymbolCreateAtomicSymbol (fromOpHandle op)+                    ("num_args" : scalarkeys)+                    (showValue (length array) : scalarvals)+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_zeros_without_dtype(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype", AttrOpt Int)]++_zeros_without_dtype ::+                     forall args . Fullfilled "_zeros_without_dtype(symbol)" args =>+                       String ->+                         ArgsHMap "_zeros_without_dtype(symbol)" args -> IO SymbolHandle+_zeros_without_dtype name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$> (args !? #dtype :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_zeros_without_dtype"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_zeros(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"]))]++_zeros ::+       forall args . Fullfilled "_zeros(symbol)" args =>+         String -> ArgsHMap "_zeros(symbol)" args -> IO SymbolHandle+_zeros name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_zeros"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_eye(symbol)" =+     '[ '("_N", AttrReq Int), '("_M", AttrOpt Int), '("k", AttrOpt Int),+        '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"]))]++_eye ::+     forall args . Fullfilled "_eye(symbol)" args =>+       String -> ArgsHMap "_eye(symbol)" args -> IO SymbolHandle+_eye name args+  = let scalarArgs+          = catMaybes+              [("_N",) . showValue <$> (args !? #_N :: Maybe Int),+               ("_M",) . showValue <$> (args !? #_M :: Maybe Int),+               ("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_eye"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_ones(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"]))]++_ones ::+      forall args . Fullfilled "_ones(symbol)" args =>+        String -> ArgsHMap "_ones(symbol)" args -> IO SymbolHandle+_ones name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_ones"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_full(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("value", AttrReq Double)]++_full ::+      forall args . Fullfilled "_full(symbol)" args =>+        String -> ArgsHMap "_full(symbol)" args -> IO SymbolHandle+_full name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"])),+               ("value",) . showValue <$> (args !? #value :: Maybe Double)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_full"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_arange(symbol)" =+     '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)),+        '("step", AttrOpt Double), '("repeat", AttrOpt Int),+        '("infer_range", AttrOpt Bool), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"]))]++_arange ::+        forall args . Fullfilled "_arange(symbol)" args =>+          String -> ArgsHMap "_arange(symbol)" args -> IO SymbolHandle+_arange name args+  = let scalarArgs+          = catMaybes+              [("start",) . showValue <$> (args !? #start :: Maybe Double),+               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),+               ("step",) . showValue <$> (args !? #step :: Maybe Double),+               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),+               ("infer_range",) . showValue <$>+                 (args !? #infer_range :: Maybe Bool),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_arange"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linspace(symbol)" =+     '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)),+        '("step", AttrOpt Double), '("repeat", AttrOpt Int),+        '("infer_range", AttrOpt Bool), '("ctx", AttrOpt String),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"]))]++_linspace ::+          forall args . Fullfilled "_linspace(symbol)" args =>+            String -> ArgsHMap "_linspace(symbol)" args -> IO SymbolHandle+_linspace name args+  = let scalarArgs+          = catMaybes+              [("start",) . showValue <$> (args !? #start :: Maybe Double),+               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),+               ("step",) . showValue <$> (args !? #step :: Maybe Double),+               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),+               ("infer_range",) . showValue <$>+                 (args !? #infer_range :: Maybe Bool),+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linspace"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "zeros_like(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++zeros_like ::+           forall args . Fullfilled "zeros_like(symbol)" args =>+             String -> ArgsHMap "zeros_like(symbol)" args -> IO SymbolHandle+zeros_like name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "zeros_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "ones_like(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++ones_like ::+          forall args . Fullfilled "ones_like(symbol)" args =>+            String -> ArgsHMap "ones_like(symbol)" args -> IO SymbolHandle+ones_like name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ones_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_add(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_add ::+              forall args . Fullfilled "broadcast_add(symbol)" args =>+                String -> ArgsHMap "broadcast_add(symbol)" args -> IO SymbolHandle+broadcast_add name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_add"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_add(symbol)" = '[]++_backward_broadcast_add ::+                        forall args . Fullfilled "_backward_broadcast_add(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_broadcast_add(symbol)" args -> IO SymbolHandle+_backward_broadcast_add name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_add"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_sub(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_sub ::+              forall args . Fullfilled "broadcast_sub(symbol)" args =>+                String -> ArgsHMap "broadcast_sub(symbol)" args -> IO SymbolHandle+broadcast_sub name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_sub"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_sub(symbol)" = '[]++_backward_broadcast_sub ::+                        forall args . Fullfilled "_backward_broadcast_sub(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_broadcast_sub(symbol)" args -> IO SymbolHandle+_backward_broadcast_sub name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_sub"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_mul(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_mul ::+              forall args . Fullfilled "broadcast_mul(symbol)" args =>+                String -> ArgsHMap "broadcast_mul(symbol)" args -> IO SymbolHandle+broadcast_mul name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_mul"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_mul(symbol)" = '[]++_backward_broadcast_mul ::+                        forall args . Fullfilled "_backward_broadcast_mul(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_broadcast_mul(symbol)" args -> IO SymbolHandle+_backward_broadcast_mul name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_mul"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_div(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_div ::+              forall args . Fullfilled "broadcast_div(symbol)" args =>+                String -> ArgsHMap "broadcast_div(symbol)" args -> IO SymbolHandle+broadcast_div name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_div"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_div(symbol)" = '[]++_backward_broadcast_div ::+                        forall args . Fullfilled "_backward_broadcast_div(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_broadcast_div(symbol)" args -> IO SymbolHandle+_backward_broadcast_div name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_div"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_mod(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_mod ::+              forall args . Fullfilled "broadcast_mod(symbol)" args =>+                String -> ArgsHMap "broadcast_mod(symbol)" args -> IO SymbolHandle+broadcast_mod name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_mod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_broadcast_mod(symbol)" = '[]++_backward_broadcast_mod ::+                        forall args . Fullfilled "_backward_broadcast_mod(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_broadcast_mod(symbol)" args -> IO SymbolHandle+_backward_broadcast_mod name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_broadcast_mod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_gemm(symbol)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("alpha", AttrOpt Double), '("beta", AttrOpt Double),+        '("axis", AttrOpt Int), '("_A", AttrOpt SymbolHandle),+        '("_B", AttrOpt SymbolHandle), '("_C", AttrOpt SymbolHandle)]++_linalg_gemm ::+             forall args . Fullfilled "_linalg_gemm(symbol)" args =>+               String -> ArgsHMap "_linalg_gemm(symbol)" args -> IO SymbolHandle+_linalg_gemm name args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Double),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),+               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle),+               ("_C",) <$> (args !? #_C :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gemm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_gemm(symbol)" = '[]++_backward_linalg_gemm ::+                      forall args . Fullfilled "_backward_linalg_gemm(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_linalg_gemm(symbol)" args -> IO SymbolHandle+_backward_linalg_gemm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gemm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_gemm2(symbol)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("alpha", AttrOpt Double), '("axis", AttrOpt Int),+        '("_A", AttrOpt SymbolHandle), '("_B", AttrOpt SymbolHandle)]++_linalg_gemm2 ::+              forall args . Fullfilled "_linalg_gemm2(symbol)" args =>+                String -> ArgsHMap "_linalg_gemm2(symbol)" args -> IO SymbolHandle+_linalg_gemm2 name args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),+               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gemm2"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_gemm2(symbol)" = '[]++_backward_linalg_gemm2 ::+                       forall args . Fullfilled "_backward_linalg_gemm2(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_linalg_gemm2(symbol)" args -> IO SymbolHandle+_backward_linalg_gemm2 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gemm2"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_potrf(symbol)" =+     '[ '("_A", AttrOpt SymbolHandle)]++_linalg_potrf ::+              forall args . Fullfilled "_linalg_potrf(symbol)" args =>+                String -> ArgsHMap "_linalg_potrf(symbol)" args -> IO SymbolHandle+_linalg_potrf name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_potrf"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_potrf(symbol)" = '[]++_backward_linalg_potrf ::+                       forall args . Fullfilled "_backward_linalg_potrf(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_linalg_potrf(symbol)" args -> IO SymbolHandle+_backward_linalg_potrf name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_potrf"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_potri(symbol)" =+     '[ '("_A", AttrOpt SymbolHandle)]++_linalg_potri ::+              forall args . Fullfilled "_linalg_potri(symbol)" args =>+                String -> ArgsHMap "_linalg_potri(symbol)" args -> IO SymbolHandle+_linalg_potri name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_potri"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_potri(symbol)" = '[]++_backward_linalg_potri ::+                       forall args . Fullfilled "_backward_linalg_potri(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_linalg_potri(symbol)" args -> IO SymbolHandle+_backward_linalg_potri name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_potri"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_trmm(symbol)" =+     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),+        '("lower", AttrOpt Bool), '("alpha", AttrOpt Double),+        '("_A", AttrOpt SymbolHandle), '("_B", AttrOpt SymbolHandle)]++_linalg_trmm ::+             forall args . Fullfilled "_linalg_trmm(symbol)" args =>+               String -> ArgsHMap "_linalg_trmm(symbol)" args -> IO SymbolHandle+_linalg_trmm name args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),+               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),+               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_trmm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_trmm(symbol)" = '[]++_backward_linalg_trmm ::+                      forall args . Fullfilled "_backward_linalg_trmm(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_linalg_trmm(symbol)" args -> IO SymbolHandle+_backward_linalg_trmm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_trmm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_trsm(symbol)" =+     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),+        '("lower", AttrOpt Bool), '("alpha", AttrOpt Double),+        '("_A", AttrOpt SymbolHandle), '("_B", AttrOpt SymbolHandle)]++_linalg_trsm ::+             forall args . Fullfilled "_linalg_trsm(symbol)" args =>+               String -> ArgsHMap "_linalg_trsm(symbol)" args -> IO SymbolHandle+_linalg_trsm name args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),+               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),+               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_trsm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_trsm(symbol)" = '[]++_backward_linalg_trsm ::+                      forall args . Fullfilled "_backward_linalg_trsm(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_linalg_trsm(symbol)" args -> IO SymbolHandle+_backward_linalg_trsm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_trsm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_sumlogdiag(symbol)" =+     '[ '("_A", AttrOpt SymbolHandle)]++_linalg_sumlogdiag ::+                   forall args . Fullfilled "_linalg_sumlogdiag(symbol)" args =>+                     String ->+                       ArgsHMap "_linalg_sumlogdiag(symbol)" args -> IO SymbolHandle+_linalg_sumlogdiag name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_sumlogdiag"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_sumlogdiag(symbol)" =+     '[]++_backward_linalg_sumlogdiag ::+                            forall args .+                              Fullfilled "_backward_linalg_sumlogdiag(symbol)" args =>+                              String ->+                                ArgsHMap "_backward_linalg_sumlogdiag(symbol)" args ->+                                  IO SymbolHandle+_backward_linalg_sumlogdiag name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_sumlogdiag"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_extractdiag(symbol)" =+     '[ '("offset", AttrOpt Int), '("_A", AttrOpt SymbolHandle)]++_linalg_extractdiag ::+                    forall args . Fullfilled "_linalg_extractdiag(symbol)" args =>+                      String ->+                        ArgsHMap "_linalg_extractdiag(symbol)" args -> IO SymbolHandle+_linalg_extractdiag name args+  = let scalarArgs+          = catMaybes+              [("offset",) . showValue <$> (args !? #offset :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_extractdiag"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_extractdiag(symbol)"+     = '[]++_backward_linalg_extractdiag ::+                             forall args .+                               Fullfilled "_backward_linalg_extractdiag(symbol)" args =>+                               String ->+                                 ArgsHMap "_backward_linalg_extractdiag(symbol)" args ->+                                   IO SymbolHandle+_backward_linalg_extractdiag name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_extractdiag"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_makediag(symbol)" =+     '[ '("offset", AttrOpt Int), '("_A", AttrOpt SymbolHandle)]++_linalg_makediag ::+                 forall args . Fullfilled "_linalg_makediag(symbol)" args =>+                   String ->+                     ArgsHMap "_linalg_makediag(symbol)" args -> IO SymbolHandle+_linalg_makediag name args+  = let scalarArgs+          = catMaybes+              [("offset",) . showValue <$> (args !? #offset :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_makediag"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_makediag(symbol)" =+     '[]++_backward_linalg_makediag ::+                          forall args .+                            Fullfilled "_backward_linalg_makediag(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_linalg_makediag(symbol)" args ->+                                IO SymbolHandle+_backward_linalg_makediag name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_makediag"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_extracttrian(symbol)" =+     '[ '("offset", AttrOpt Int), '("lower", AttrOpt Bool),+        '("_A", AttrOpt SymbolHandle)]++_linalg_extracttrian ::+                     forall args . Fullfilled "_linalg_extracttrian(symbol)" args =>+                       String ->+                         ArgsHMap "_linalg_extracttrian(symbol)" args -> IO SymbolHandle+_linalg_extracttrian name args+  = let scalarArgs+          = catMaybes+              [("offset",) . showValue <$> (args !? #offset :: Maybe Int),+               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_extracttrian"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_extracttrian(symbol)"+     = '[]++_backward_linalg_extracttrian ::+                              forall args .+                                Fullfilled "_backward_linalg_extracttrian(symbol)" args =>+                                String ->+                                  ArgsHMap "_backward_linalg_extracttrian(symbol)" args ->+                                    IO SymbolHandle+_backward_linalg_extracttrian name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_extracttrian"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_maketrian(symbol)" =+     '[ '("offset", AttrOpt Int), '("lower", AttrOpt Bool),+        '("_A", AttrOpt SymbolHandle)]++_linalg_maketrian ::+                  forall args . Fullfilled "_linalg_maketrian(symbol)" args =>+                    String ->+                      ArgsHMap "_linalg_maketrian(symbol)" args -> IO SymbolHandle+_linalg_maketrian name args+  = let scalarArgs+          = catMaybes+              [("offset",) . showValue <$> (args !? #offset :: Maybe Int),+               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_maketrian"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_maketrian(symbol)" =+     '[]++_backward_linalg_maketrian ::+                           forall args .+                             Fullfilled "_backward_linalg_maketrian(symbol)" args =>+                             String ->+                               ArgsHMap "_backward_linalg_maketrian(symbol)" args ->+                                 IO SymbolHandle+_backward_linalg_maketrian name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_maketrian"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_syrk(symbol)" =+     '[ '("transpose", AttrOpt Bool), '("alpha", AttrOpt Double),+        '("_A", AttrOpt SymbolHandle)]++_linalg_syrk ::+             forall args . Fullfilled "_linalg_syrk(symbol)" args =>+               String -> ArgsHMap "_linalg_syrk(symbol)" args -> IO SymbolHandle+_linalg_syrk name args+  = let scalarArgs+          = catMaybes+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_syrk"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_syrk(symbol)" = '[]++_backward_linalg_syrk ::+                      forall args . Fullfilled "_backward_linalg_syrk(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_linalg_syrk(symbol)" args -> IO SymbolHandle+_backward_linalg_syrk name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_syrk"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_gelqf(symbol)" =+     '[ '("_A", AttrOpt SymbolHandle)]++_linalg_gelqf ::+              forall args . Fullfilled "_linalg_gelqf(symbol)" args =>+                String -> ArgsHMap "_linalg_gelqf(symbol)" args -> IO SymbolHandle+_linalg_gelqf name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_gelqf"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_gelqf(symbol)" = '[]++_backward_linalg_gelqf ::+                       forall args . Fullfilled "_backward_linalg_gelqf(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_linalg_gelqf(symbol)" args -> IO SymbolHandle+_backward_linalg_gelqf name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_gelqf"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_syevd(symbol)" =+     '[ '("_A", AttrOpt SymbolHandle)]++_linalg_syevd ::+              forall args . Fullfilled "_linalg_syevd(symbol)" args =>+                String -> ArgsHMap "_linalg_syevd(symbol)" args -> IO SymbolHandle+_linalg_syevd name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_syevd"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_syevd(symbol)" = '[]++_backward_linalg_syevd ::+                       forall args . Fullfilled "_backward_linalg_syevd(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_linalg_syevd(symbol)" args -> IO SymbolHandle+_backward_linalg_syevd name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_syevd"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_linalg_inverse(symbol)" =+     '[ '("_A", AttrOpt SymbolHandle)]++_linalg_inverse ::+                forall args . Fullfilled "_linalg_inverse(symbol)" args =>+                  String ->+                    ArgsHMap "_linalg_inverse(symbol)" args -> IO SymbolHandle+_linalg_inverse name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_linalg_inverse"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linalg_inverse(symbol)" =+     '[]++_backward_linalg_inverse ::+                         forall args . Fullfilled "_backward_linalg_inverse(symbol)" args =>+                           String ->+                             ArgsHMap "_backward_linalg_inverse(symbol)" args -> IO SymbolHandle+_backward_linalg_inverse name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linalg_inverse"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_histogram(symbol)" =+     '[ '("bin_cnt", AttrOpt (Maybe Int)), '("range", AttrOpt Int),+        '("data", AttrOpt SymbolHandle), '("bins", AttrOpt SymbolHandle)]++_histogram ::+           forall args . Fullfilled "_histogram(symbol)" args =>+             String -> ArgsHMap "_histogram(symbol)" args -> IO SymbolHandle+_histogram name args+  = let scalarArgs+          = catMaybes+              [("bin_cnt",) . showValue <$>+                 (args !? #bin_cnt :: Maybe (Maybe Int)),+               ("range",) . showValue <$> (args !? #range :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("bins",) <$> (args !? #bins :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_histogram"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "cast_storage(symbol)" =+     '[ '("stype",+          AttrReq (EnumType '["csr", "default", "row_sparse"])),+        '("data", AttrOpt SymbolHandle)]++cast_storage ::+             forall args . Fullfilled "cast_storage(symbol)" args =>+               String -> ArgsHMap "cast_storage(symbol)" args -> IO SymbolHandle+cast_storage name args+  = let scalarArgs+          = catMaybes+              [("stype",) . showValue <$>+                 (args !? #stype ::+                    Maybe (EnumType '["csr", "default", "row_sparse"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cast_storage"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_equal_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_equal_scalar ::+              forall args . Fullfilled "_equal_scalar(symbol)" args =>+                String -> ArgsHMap "_equal_scalar(symbol)" args -> IO SymbolHandle+_equal_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_equal_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_not_equal_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_not_equal_scalar ::+                  forall args . Fullfilled "_not_equal_scalar(symbol)" args =>+                    String ->+                      ArgsHMap "_not_equal_scalar(symbol)" args -> IO SymbolHandle+_not_equal_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_not_equal_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_greater_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_greater_scalar ::+                forall args . Fullfilled "_greater_scalar(symbol)" args =>+                  String ->+                    ArgsHMap "_greater_scalar(symbol)" args -> IO SymbolHandle+_greater_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_greater_equal_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_greater_equal_scalar ::+                      forall args . Fullfilled "_greater_equal_scalar(symbol)" args =>+                        String ->+                          ArgsHMap "_greater_equal_scalar(symbol)" args -> IO SymbolHandle+_greater_equal_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_greater_equal_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_lesser_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_lesser_scalar ::+               forall args . Fullfilled "_lesser_scalar(symbol)" args =>+                 String -> ArgsHMap "_lesser_scalar(symbol)" args -> IO SymbolHandle+_lesser_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_lesser_equal_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_lesser_equal_scalar ::+                     forall args . Fullfilled "_lesser_equal_scalar(symbol)" args =>+                       String ->+                         ArgsHMap "_lesser_equal_scalar(symbol)" args -> IO SymbolHandle+_lesser_equal_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_lesser_equal_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_logical_and_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_logical_and_scalar ::+                    forall args . Fullfilled "_logical_and_scalar(symbol)" args =>+                      String ->+                        ArgsHMap "_logical_and_scalar(symbol)" args -> IO SymbolHandle+_logical_and_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_and_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_logical_or_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_logical_or_scalar ::+                   forall args . Fullfilled "_logical_or_scalar(symbol)" args =>+                     String ->+                       ArgsHMap "_logical_or_scalar(symbol)" args -> IO SymbolHandle+_logical_or_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_or_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_logical_xor_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_logical_xor_scalar ::+                    forall args . Fullfilled "_logical_xor_scalar(symbol)" args =>+                      String ->+                        ArgsHMap "_logical_xor_scalar(symbol)" args -> IO SymbolHandle+_logical_xor_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_logical_xor_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "relu(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++relu ::+     forall args . Fullfilled "relu(symbol)" args =>+       String -> ArgsHMap "relu(symbol)" args -> IO SymbolHandle+relu name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "relu"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_relu(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_relu ::+               forall args . Fullfilled "_backward_relu(symbol)" args =>+                 String -> ArgsHMap "_backward_relu(symbol)" args -> IO SymbolHandle+_backward_relu name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_relu"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sigmoid(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++sigmoid ::+        forall args . Fullfilled "sigmoid(symbol)" args =>+          String -> ArgsHMap "sigmoid(symbol)" args -> IO SymbolHandle+sigmoid name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sigmoid"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sigmoid(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_sigmoid ::+                  forall args . Fullfilled "_backward_sigmoid(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_sigmoid(symbol)" args -> IO SymbolHandle+_backward_sigmoid name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sigmoid"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "hard_sigmoid(symbol)" =+     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),+        '("data", AttrOpt SymbolHandle)]++hard_sigmoid ::+             forall args . Fullfilled "hard_sigmoid(symbol)" args =>+               String -> ArgsHMap "hard_sigmoid(symbol)" args -> IO SymbolHandle+hard_sigmoid name args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "hard_sigmoid"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_hard_sigmoid(symbol)" = '[]++_backward_hard_sigmoid ::+                       forall args . Fullfilled "_backward_hard_sigmoid(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_hard_sigmoid(symbol)" args -> IO SymbolHandle+_backward_hard_sigmoid name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_hard_sigmoid"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "softsign(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++softsign ::+         forall args . Fullfilled "softsign(symbol)" args =>+           String -> ArgsHMap "softsign(symbol)" args -> IO SymbolHandle+softsign name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softsign"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_softsign(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_softsign ::+                   forall args . Fullfilled "_backward_softsign(symbol)" args =>+                     String ->+                       ArgsHMap "_backward_softsign(symbol)" args -> IO SymbolHandle+_backward_softsign name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_softsign"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_copy(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++_copy ::+      forall args . Fullfilled "_copy(symbol)" args =>+        String -> ArgsHMap "_copy(symbol)" args -> IO SymbolHandle+_copy name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_copy"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_copy(symbol)" = '[]++_backward_copy ::+               forall args . Fullfilled "_backward_copy(symbol)" args =>+                 String -> ArgsHMap "_backward_copy(symbol)" args -> IO SymbolHandle+_backward_copy name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_copy"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_reshape(symbol)" = '[]++_backward_reshape ::+                  forall args . Fullfilled "_backward_reshape(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_reshape(symbol)" args -> IO SymbolHandle+_backward_reshape name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_reshape"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_BlockGrad(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++_BlockGrad ::+           forall args . Fullfilled "_BlockGrad(symbol)" args =>+             String -> ArgsHMap "_BlockGrad(symbol)" args -> IO SymbolHandle+_BlockGrad name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BlockGrad"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "make_loss(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++make_loss ::+          forall args . Fullfilled "make_loss(symbol)" args =>+            String -> ArgsHMap "make_loss(symbol)" args -> IO SymbolHandle+make_loss name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "make_loss"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_identity_with_attr_like_rhs(symbol)"+     =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_identity_with_attr_like_rhs ::+                             forall args .+                               Fullfilled "_identity_with_attr_like_rhs(symbol)" args =>+                               String ->+                                 ArgsHMap "_identity_with_attr_like_rhs(symbol)" args ->+                                   IO SymbolHandle+_identity_with_attr_like_rhs name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_identity_with_attr_like_rhs"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "reshape_like(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++reshape_like ::+             forall args . Fullfilled "reshape_like(symbol)" args =>+               String -> ArgsHMap "reshape_like(symbol)" args -> IO SymbolHandle+reshape_like name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reshape_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "shape_array(symbol)" =+     '[ '("lhs_begin", AttrOpt (Maybe Int)),+        '("lhs_end", AttrOpt (Maybe Int)),+        '("rhs_begin", AttrOpt (Maybe Int)),+        '("rhs_end", AttrOpt (Maybe Int)), '("data", AttrOpt SymbolHandle)]++shape_array ::+            forall args . Fullfilled "shape_array(symbol)" args =>+              String -> ArgsHMap "shape_array(symbol)" args -> IO SymbolHandle+shape_array name args+  = let scalarArgs+          = catMaybes+              [("lhs_begin",) . showValue <$>+                 (args !? #lhs_begin :: Maybe (Maybe Int)),+               ("lhs_end",) . showValue <$>+                 (args !? #lhs_end :: Maybe (Maybe Int)),+               ("rhs_begin",) . showValue <$>+                 (args !? #rhs_begin :: Maybe (Maybe Int)),+               ("rhs_end",) . showValue <$>+                 (args !? #rhs_end :: Maybe (Maybe Int))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "shape_array"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "size_array(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++size_array ::+           forall args . Fullfilled "size_array(symbol)" args =>+             String -> ArgsHMap "size_array(symbol)" args -> IO SymbolHandle+size_array name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "size_array"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Cast(symbol)" =+     '[ '("dtype",+          AttrReq+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("data", AttrOpt SymbolHandle)]++_Cast ::+      forall args . Fullfilled "_Cast(symbol)" args =>+        String -> ArgsHMap "_Cast(symbol)" args -> IO SymbolHandle+_Cast name args+  = let scalarArgs+          = catMaybes+              [("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Cast"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_cast(symbol)" = '[]++_backward_cast ::+               forall args . Fullfilled "_backward_cast(symbol)" args =>+                 String -> ArgsHMap "_backward_cast(symbol)" args -> IO SymbolHandle+_backward_cast name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cast"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "negative(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++negative ::+         forall args . Fullfilled "negative(symbol)" args =>+           String -> ArgsHMap "negative(symbol)" args -> IO SymbolHandle+negative name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "negative"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "reciprocal(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++reciprocal ::+           forall args . Fullfilled "reciprocal(symbol)" args =>+             String -> ArgsHMap "reciprocal(symbol)" args -> IO SymbolHandle+reciprocal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reciprocal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_reciprocal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_reciprocal ::+                     forall args . Fullfilled "_backward_reciprocal(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_reciprocal(symbol)" args -> IO SymbolHandle+_backward_reciprocal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_reciprocal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "abs(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++abs ::+    forall args . Fullfilled "abs(symbol)" args =>+      String -> ArgsHMap "abs(symbol)" args -> IO SymbolHandle+abs name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "abs"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_abs(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_abs ::+              forall args . Fullfilled "_backward_abs(symbol)" args =>+                String -> ArgsHMap "_backward_abs(symbol)" args -> IO SymbolHandle+_backward_abs name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_abs"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sign(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++sign ::+     forall args . Fullfilled "sign(symbol)" args =>+       String -> ArgsHMap "sign(symbol)" args -> IO SymbolHandle+sign name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sign"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sign(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_sign ::+               forall args . Fullfilled "_backward_sign(symbol)" args =>+                 String -> ArgsHMap "_backward_sign(symbol)" args -> IO SymbolHandle+_backward_sign name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sign"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "round(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++round ::+      forall args . Fullfilled "round(symbol)" args =>+        String -> ArgsHMap "round(symbol)" args -> IO SymbolHandle+round name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "round"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "rint(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++rint ::+     forall args . Fullfilled "rint(symbol)" args =>+       String -> ArgsHMap "rint(symbol)" args -> IO SymbolHandle+rint name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rint"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "ceil(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++ceil ::+     forall args . Fullfilled "ceil(symbol)" args =>+       String -> ArgsHMap "ceil(symbol)" args -> IO SymbolHandle+ceil name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ceil"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "floor(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++floor ::+      forall args . Fullfilled "floor(symbol)" args =>+        String -> ArgsHMap "floor(symbol)" args -> IO SymbolHandle+floor name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "floor"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "trunc(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++trunc ::+      forall args . Fullfilled "trunc(symbol)" args =>+        String -> ArgsHMap "trunc(symbol)" args -> IO SymbolHandle+trunc name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "trunc"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "fix(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++fix ::+    forall args . Fullfilled "fix(symbol)" args =>+      String -> ArgsHMap "fix(symbol)" args -> IO SymbolHandle+fix name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "fix"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "square(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++square ::+       forall args . Fullfilled "square(symbol)" args =>+         String -> ArgsHMap "square(symbol)" args -> IO SymbolHandle+square name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "square"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_square(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_square ::+                 forall args . Fullfilled "_backward_square(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_square(symbol)" args -> IO SymbolHandle+_backward_square name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_square"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sqrt(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++sqrt ::+     forall args . Fullfilled "sqrt(symbol)" args =>+       String -> ArgsHMap "sqrt(symbol)" args -> IO SymbolHandle+sqrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sqrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sqrt(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_sqrt ::+               forall args . Fullfilled "_backward_sqrt(symbol)" args =>+                 String -> ArgsHMap "_backward_sqrt(symbol)" args -> IO SymbolHandle+_backward_sqrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sqrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "rsqrt(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++rsqrt ::+      forall args . Fullfilled "rsqrt(symbol)" args =>+        String -> ArgsHMap "rsqrt(symbol)" args -> IO SymbolHandle+rsqrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rsqrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_rsqrt(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_rsqrt ::+                forall args . Fullfilled "_backward_rsqrt(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_rsqrt(symbol)" args -> IO SymbolHandle+_backward_rsqrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rsqrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "cbrt(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++cbrt ::+     forall args . Fullfilled "cbrt(symbol)" args =>+       String -> ArgsHMap "cbrt(symbol)" args -> IO SymbolHandle+cbrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cbrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_cbrt(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_cbrt ::+               forall args . Fullfilled "_backward_cbrt(symbol)" args =>+                 String -> ArgsHMap "_backward_cbrt(symbol)" args -> IO SymbolHandle+_backward_cbrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cbrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "erf(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++erf ::+    forall args . Fullfilled "erf(symbol)" args =>+      String -> ArgsHMap "erf(symbol)" args -> IO SymbolHandle+erf name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "erf"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_erf(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_erf ::+              forall args . Fullfilled "_backward_erf(symbol)" args =>+                String -> ArgsHMap "_backward_erf(symbol)" args -> IO SymbolHandle+_backward_erf name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_erf"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "erfinv(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++erfinv ::+       forall args . Fullfilled "erfinv(symbol)" args =>+         String -> ArgsHMap "erfinv(symbol)" args -> IO SymbolHandle+erfinv name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "erfinv"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_erfinv(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_erfinv ::+                 forall args . Fullfilled "_backward_erfinv(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_erfinv(symbol)" args -> IO SymbolHandle+_backward_erfinv name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_erfinv"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "rcbrt(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++rcbrt ::+      forall args . Fullfilled "rcbrt(symbol)" args =>+        String -> ArgsHMap "rcbrt(symbol)" args -> IO SymbolHandle+rcbrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rcbrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_rcbrt(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_rcbrt ::+                forall args . Fullfilled "_backward_rcbrt(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_rcbrt(symbol)" args -> IO SymbolHandle+_backward_rcbrt name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rcbrt"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "exp(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++exp ::+    forall args . Fullfilled "exp(symbol)" args =>+      String -> ArgsHMap "exp(symbol)" args -> IO SymbolHandle+exp name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "exp"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "log(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++log ::+    forall args . Fullfilled "log(symbol)" args =>+      String -> ArgsHMap "log(symbol)" args -> IO SymbolHandle+log name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "log10(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++log10 ::+      forall args . Fullfilled "log10(symbol)" args =>+        String -> ArgsHMap "log10(symbol)" args -> IO SymbolHandle+log10 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log10"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "log2(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++log2 ::+     forall args . Fullfilled "log2(symbol)" args =>+       String -> ArgsHMap "log2(symbol)" args -> IO SymbolHandle+log2 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log2"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_log(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_log ::+              forall args . Fullfilled "_backward_log(symbol)" args =>+                String -> ArgsHMap "_backward_log(symbol)" args -> IO SymbolHandle+_backward_log name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_log10(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_log10 ::+                forall args . Fullfilled "_backward_log10(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_log10(symbol)" args -> IO SymbolHandle+_backward_log10 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log10"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_log2(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_log2 ::+               forall args . Fullfilled "_backward_log2(symbol)" args =>+                 String -> ArgsHMap "_backward_log2(symbol)" args -> IO SymbolHandle+_backward_log2 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log2"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "log1p(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++log1p ::+      forall args . Fullfilled "log1p(symbol)" args =>+        String -> ArgsHMap "log1p(symbol)" args -> IO SymbolHandle+log1p name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log1p"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_log1p(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_log1p ::+                forall args . Fullfilled "_backward_log1p(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_log1p(symbol)" args -> IO SymbolHandle+_backward_log1p name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_log1p"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "expm1(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++expm1 ::+      forall args . Fullfilled "expm1(symbol)" args =>+        String -> ArgsHMap "expm1(symbol)" args -> IO SymbolHandle+expm1 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "expm1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_expm1(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_expm1 ::+                forall args . Fullfilled "_backward_expm1(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_expm1(symbol)" args -> IO SymbolHandle+_backward_expm1 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_expm1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "gamma(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++gamma ::+      forall args . Fullfilled "gamma(symbol)" args =>+        String -> ArgsHMap "gamma(symbol)" args -> IO SymbolHandle+gamma name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gamma"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_gamma(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_gamma ::+                forall args . Fullfilled "_backward_gamma(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_gamma(symbol)" args -> IO SymbolHandle+_backward_gamma name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_gamma"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "gammaln(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++gammaln ::+        forall args . Fullfilled "gammaln(symbol)" args =>+          String -> ArgsHMap "gammaln(symbol)" args -> IO SymbolHandle+gammaln name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gammaln"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_gammaln(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_gammaln ::+                  forall args . Fullfilled "_backward_gammaln(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_gammaln(symbol)" args -> IO SymbolHandle+_backward_gammaln name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_gammaln"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "logical_not(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++logical_not ::+            forall args . Fullfilled "logical_not(symbol)" args =>+              String -> ArgsHMap "logical_not(symbol)" args -> IO SymbolHandle+logical_not name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "logical_not"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "amp_cast(symbol)" =+     '[ '("dtype",+          AttrReq+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("data", AttrOpt SymbolHandle)]++amp_cast ::+         forall args . Fullfilled "amp_cast(symbol)" args =>+           String -> ArgsHMap "amp_cast(symbol)" args -> IO SymbolHandle+amp_cast name args+  = let scalarArgs+          = catMaybes+              [("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "amp_cast"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_amp_cast(symbol)" = '[]++_backward_amp_cast ::+                   forall args . Fullfilled "_backward_amp_cast(symbol)" args =>+                     String ->+                       ArgsHMap "_backward_amp_cast(symbol)" args -> IO SymbolHandle+_backward_amp_cast name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_amp_cast"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "amp_multicast(symbol)" =+     '[ '("num_outputs", AttrReq Int),+        '("data", AttrOpt [SymbolHandle])]++amp_multicast ::+              forall args . Fullfilled "amp_multicast(symbol)" args =>+                String -> ArgsHMap "amp_multicast(symbol)" args -> IO SymbolHandle+amp_multicast name args+  = let scalarArgs+          = catMaybes+              [("num_outputs",) . showValue <$>+                 (args !? #num_outputs :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "amp_multicast"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_backward_amp_multicast(symbol)" =+     '[ '("num_outputs", AttrReq Int),+        '("grad", AttrOpt [SymbolHandle])]++_backward_amp_multicast ::+                        forall args . Fullfilled "_backward_amp_multicast(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_amp_multicast(symbol)" args -> IO SymbolHandle+_backward_amp_multicast name args+  = let scalarArgs+          = catMaybes+              [("num_outputs",) . showValue <$>+                 (args !? #num_outputs :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #grad :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "_backward_amp_multicast"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "elemwise_add(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++elemwise_add ::+             forall args . Fullfilled "elemwise_add(symbol)" args =>+               String -> ArgsHMap "elemwise_add(symbol)" args -> IO SymbolHandle+elemwise_add name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_add"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_grad_add(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_grad_add ::+          forall args . Fullfilled "_grad_add(symbol)" args =>+            String -> ArgsHMap "_grad_add(symbol)" args -> IO SymbolHandle+_grad_add name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_grad_add"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_add(symbol)" = '[]++_backward_add ::+              forall args . Fullfilled "_backward_add(symbol)" args =>+                String -> ArgsHMap "_backward_add(symbol)" args -> IO SymbolHandle+_backward_add name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_add"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "elemwise_sub(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++elemwise_sub ::+             forall args . Fullfilled "elemwise_sub(symbol)" args =>+               String -> ArgsHMap "elemwise_sub(symbol)" args -> IO SymbolHandle+elemwise_sub name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_sub"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sub(symbol)" = '[]++_backward_sub ::+              forall args . Fullfilled "_backward_sub(symbol)" args =>+                String -> ArgsHMap "_backward_sub(symbol)" args -> IO SymbolHandle+_backward_sub name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sub"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "elemwise_mul(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++elemwise_mul ::+             forall args . Fullfilled "elemwise_mul(symbol)" args =>+               String -> ArgsHMap "elemwise_mul(symbol)" args -> IO SymbolHandle+elemwise_mul name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_mul"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_mul(symbol)" = '[]++_backward_mul ::+              forall args . Fullfilled "_backward_mul(symbol)" args =>+                String -> ArgsHMap "_backward_mul(symbol)" args -> IO SymbolHandle+_backward_mul name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mul"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "elemwise_div(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++elemwise_div ::+             forall args . Fullfilled "elemwise_div(symbol)" args =>+               String -> ArgsHMap "elemwise_div(symbol)" args -> IO SymbolHandle+elemwise_div name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "elemwise_div"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_div(symbol)" = '[]++_backward_div ::+              forall args . Fullfilled "_backward_div(symbol)" args =>+                String -> ArgsHMap "_backward_div(symbol)" args -> IO SymbolHandle+_backward_div name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_div"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_mod(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_mod ::+     forall args . Fullfilled "_mod(symbol)" args =>+       String -> ArgsHMap "_mod(symbol)" args -> IO SymbolHandle+_mod name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_mod(symbol)" = '[]++_backward_mod ::+              forall args . Fullfilled "_backward_mod(symbol)" args =>+                String -> ArgsHMap "_backward_mod(symbol)" args -> IO SymbolHandle+_backward_mod name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_scatter_elemwise_div(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_scatter_elemwise_div ::+                      forall args . Fullfilled "_scatter_elemwise_div(symbol)" args =>+                        String ->+                          ArgsHMap "_scatter_elemwise_div(symbol)" args -> IO SymbolHandle+_scatter_elemwise_div name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_elemwise_div"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_scatter_plus_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_scatter_plus_scalar ::+                     forall args . Fullfilled "_scatter_plus_scalar(symbol)" args =>+                       String ->+                         ArgsHMap "_scatter_plus_scalar(symbol)" args -> IO SymbolHandle+_scatter_plus_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_plus_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_scatter_minus_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_scatter_minus_scalar ::+                      forall args . Fullfilled "_scatter_minus_scalar(symbol)" args =>+                        String ->+                          ArgsHMap "_scatter_minus_scalar(symbol)" args -> IO SymbolHandle+_scatter_minus_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_minus_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Embedding(symbol)" =+     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("sparse_grad", AttrOpt Bool), '("data", AttrOpt SymbolHandle),+        '("weight", AttrOpt SymbolHandle)]++_Embedding ::+           forall args . Fullfilled "_Embedding(symbol)" args =>+             String -> ArgsHMap "_Embedding(symbol)" args -> IO SymbolHandle+_Embedding name args+  = let scalarArgs+          = catMaybes+              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"])),+               ("sparse_grad",) . showValue <$>+                 (args !? #sparse_grad :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Embedding"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_SparseEmbedding(symbol)" =+     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("sparse_grad", AttrOpt Bool), '("data", AttrOpt SymbolHandle),+        '("weight", AttrOpt SymbolHandle)]++_contrib_SparseEmbedding ::+                         forall args . Fullfilled "_contrib_SparseEmbedding(symbol)" args =>+                           String ->+                             ArgsHMap "_contrib_SparseEmbedding(symbol)" args -> IO SymbolHandle+_contrib_SparseEmbedding name args+  = let scalarArgs+          = catMaybes+              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"])),+               ("sparse_grad",) . showValue <$>+                 (args !? #sparse_grad :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_SparseEmbedding"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Embedding(symbol)" = '[]++_backward_Embedding ::+                    forall args . Fullfilled "_backward_Embedding(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_Embedding(symbol)" args -> IO SymbolHandle+_backward_Embedding name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Embedding"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SparseEmbedding(symbol)" =+     '[]++_backward_SparseEmbedding ::+                          forall args .+                            Fullfilled "_backward_SparseEmbedding(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_SparseEmbedding(symbol)" args ->+                                IO SymbolHandle+_backward_SparseEmbedding name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SparseEmbedding"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "take(symbol)" =+     '[ '("axis", AttrOpt Int),+        '("mode", AttrOpt (EnumType '["clip", "raise", "wrap"])),+        '("a", AttrOpt SymbolHandle), '("indices", AttrOpt SymbolHandle)]++take ::+     forall args . Fullfilled "take(symbol)" args =>+       String -> ArgsHMap "take(symbol)" args -> IO SymbolHandle+take name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("a",) <$> (args !? #a :: Maybe SymbolHandle),+               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "take"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_take(symbol)" = '[]++_backward_take ::+               forall args . Fullfilled "_backward_take(symbol)" args =>+                 String -> ArgsHMap "_backward_take(symbol)" args -> IO SymbolHandle+_backward_take name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_take"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "batch_take(symbol)" =+     '[ '("a", AttrOpt SymbolHandle),+        '("indices", AttrOpt SymbolHandle)]++batch_take ::+           forall args . Fullfilled "batch_take(symbol)" args =>+             String -> ArgsHMap "batch_take(symbol)" args -> IO SymbolHandle+batch_take name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("a",) <$> (args !? #a :: Maybe SymbolHandle),+               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "batch_take"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "one_hot(symbol)" =+     '[ '("depth", AttrReq Int), '("on_value", AttrOpt Double),+        '("off_value", AttrOpt Double),+        '("dtype",+          AttrOpt+            (EnumType+               '["float16", "float32", "float64", "int32", "int64", "int8",+                 "uint8"])),+        '("indices", AttrOpt SymbolHandle)]++one_hot ::+        forall args . Fullfilled "one_hot(symbol)" args =>+          String -> ArgsHMap "one_hot(symbol)" args -> IO SymbolHandle+one_hot name args+  = let scalarArgs+          = catMaybes+              [("depth",) . showValue <$> (args !? #depth :: Maybe Int),+               ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double),+               ("off_value",) . showValue <$>+                 (args !? #off_value :: Maybe Double),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType+                         '["float16", "float32", "float64", "int32", "int64", "int8",+                           "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "one_hot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "gather_nd(symbol)" =+     '[ '("data", AttrOpt SymbolHandle),+        '("indices", AttrOpt SymbolHandle)]++gather_nd ::+          forall args . Fullfilled "gather_nd(symbol)" args =>+            String -> ArgsHMap "gather_nd(symbol)" args -> IO SymbolHandle+gather_nd name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "gather_nd"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "scatter_nd(symbol)" =+     '[ '("shape", AttrReq [Int]), '("data", AttrOpt SymbolHandle),+        '("indices", AttrOpt SymbolHandle)]++scatter_nd ::+           forall args . Fullfilled "scatter_nd(symbol)" args =>+             String -> ArgsHMap "scatter_nd(symbol)" args -> IO SymbolHandle+scatter_nd name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "scatter_nd"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_gather_nd(symbol)" =+     '[ '("shape", AttrReq [Int]), '("data", AttrOpt SymbolHandle),+        '("indices", AttrOpt SymbolHandle)]++_backward_gather_nd ::+                    forall args . Fullfilled "_backward_gather_nd(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_gather_nd(symbol)" args -> IO SymbolHandle+_backward_gather_nd name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_gather_nd"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_scatter_set_nd(symbol)" =+     '[ '("shape", AttrReq [Int]), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle), '("indices", AttrOpt SymbolHandle)]++_scatter_set_nd ::+                forall args . Fullfilled "_scatter_set_nd(symbol)" args =>+                  String ->+                    ArgsHMap "_scatter_set_nd(symbol)" args -> IO SymbolHandle+_scatter_set_nd name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle),+               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_scatter_set_nd"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_equal ::+                forall args . Fullfilled "broadcast_equal(symbol)" args =>+                  String ->+                    ArgsHMap "broadcast_equal(symbol)" args -> IO SymbolHandle+broadcast_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_not_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_not_equal ::+                    forall args . Fullfilled "broadcast_not_equal(symbol)" args =>+                      String ->+                        ArgsHMap "broadcast_not_equal(symbol)" args -> IO SymbolHandle+broadcast_not_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_not_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_greater(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_greater ::+                  forall args . Fullfilled "broadcast_greater(symbol)" args =>+                    String ->+                      ArgsHMap "broadcast_greater(symbol)" args -> IO SymbolHandle+broadcast_greater name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_greater"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_greater_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_greater_equal ::+                        forall args . Fullfilled "broadcast_greater_equal(symbol)" args =>+                          String ->+                            ArgsHMap "broadcast_greater_equal(symbol)" args -> IO SymbolHandle+broadcast_greater_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_greater_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_lesser(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_lesser ::+                 forall args . Fullfilled "broadcast_lesser(symbol)" args =>+                   String ->+                     ArgsHMap "broadcast_lesser(symbol)" args -> IO SymbolHandle+broadcast_lesser name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_lesser"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_lesser_equal(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_lesser_equal ::+                       forall args . Fullfilled "broadcast_lesser_equal(symbol)" args =>+                         String ->+                           ArgsHMap "broadcast_lesser_equal(symbol)" args -> IO SymbolHandle+broadcast_lesser_equal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_lesser_equal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_logical_and(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_logical_and ::+                      forall args . Fullfilled "broadcast_logical_and(symbol)" args =>+                        String ->+                          ArgsHMap "broadcast_logical_and(symbol)" args -> IO SymbolHandle+broadcast_logical_and name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_logical_and"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_logical_or(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_logical_or ::+                     forall args . Fullfilled "broadcast_logical_or(symbol)" args =>+                       String ->+                         ArgsHMap "broadcast_logical_or(symbol)" args -> IO SymbolHandle+broadcast_logical_or name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_logical_or"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_logical_xor(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_logical_xor ::+                      forall args . Fullfilled "broadcast_logical_xor(symbol)" args =>+                        String ->+                          ArgsHMap "broadcast_logical_xor(symbol)" args -> IO SymbolHandle+broadcast_logical_xor name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_logical_xor"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_plus_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_plus_scalar ::+             forall args . Fullfilled "_plus_scalar(symbol)" args =>+               String -> ArgsHMap "_plus_scalar(symbol)" args -> IO SymbolHandle+_plus_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_plus_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_minus_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_minus_scalar ::+              forall args . Fullfilled "_minus_scalar(symbol)" args =>+                String -> ArgsHMap "_minus_scalar(symbol)" args -> IO SymbolHandle+_minus_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minus_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_rminus_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_rminus_scalar ::+               forall args . Fullfilled "_rminus_scalar(symbol)" args =>+                 String -> ArgsHMap "_rminus_scalar(symbol)" args -> IO SymbolHandle+_rminus_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rminus_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_mul_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_mul_scalar ::+            forall args . Fullfilled "_mul_scalar(symbol)" args =>+              String -> ArgsHMap "_mul_scalar(symbol)" args -> IO SymbolHandle+_mul_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mul_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_mul_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_backward_mul_scalar ::+                     forall args . Fullfilled "_backward_mul_scalar(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_mul_scalar(symbol)" args -> IO SymbolHandle+_backward_mul_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mul_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_div_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_div_scalar ::+            forall args . Fullfilled "_div_scalar(symbol)" args =>+              String -> ArgsHMap "_div_scalar(symbol)" args -> IO SymbolHandle+_div_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_div_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_div_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_backward_div_scalar ::+                     forall args . Fullfilled "_backward_div_scalar(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_div_scalar(symbol)" args -> IO SymbolHandle+_backward_div_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_div_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_rdiv_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_rdiv_scalar ::+             forall args . Fullfilled "_rdiv_scalar(symbol)" args =>+               String -> ArgsHMap "_rdiv_scalar(symbol)" args -> IO SymbolHandle+_rdiv_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rdiv_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_rdiv_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_rdiv_scalar ::+                      forall args . Fullfilled "_backward_rdiv_scalar(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_rdiv_scalar(symbol)" args -> IO SymbolHandle+_backward_rdiv_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rdiv_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_mod_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_mod_scalar ::+            forall args . Fullfilled "_mod_scalar(symbol)" args =>+              String -> ArgsHMap "_mod_scalar(symbol)" args -> IO SymbolHandle+_mod_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mod_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_mod_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_mod_scalar ::+                     forall args . Fullfilled "_backward_mod_scalar(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_mod_scalar(symbol)" args -> IO SymbolHandle+_backward_mod_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mod_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_rmod_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_rmod_scalar ::+             forall args . Fullfilled "_rmod_scalar(symbol)" args =>+               String -> ArgsHMap "_rmod_scalar(symbol)" args -> IO SymbolHandle+_rmod_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rmod_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_rmod_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_rmod_scalar ::+                      forall args . Fullfilled "_backward_rmod_scalar(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_rmod_scalar(symbol)" args -> IO SymbolHandle+_backward_rmod_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rmod_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_ravel_multi_index(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]++_ravel_multi_index ::+                   forall args . Fullfilled "_ravel_multi_index(symbol)" args =>+                     String ->+                       ArgsHMap "_ravel_multi_index(symbol)" args -> IO SymbolHandle+_ravel_multi_index name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_ravel_multi_index"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_unravel_index(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]++_unravel_index ::+               forall args . Fullfilled "_unravel_index(symbol)" args =>+                 String -> ArgsHMap "_unravel_index(symbol)" args -> IO SymbolHandle+_unravel_index name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_unravel_index"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sum(symbol)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++sum ::+    forall args . Fullfilled "sum(symbol)" args =>+      String -> ArgsHMap "sum(symbol)" args -> IO SymbolHandle+sum name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sum(symbol)" = '[]++_backward_sum ::+              forall args . Fullfilled "_backward_sum(symbol)" args =>+                String -> ArgsHMap "_backward_sum(symbol)" args -> IO SymbolHandle+_backward_sum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "mean(symbol)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++mean ::+     forall args . Fullfilled "mean(symbol)" args =>+       String -> ArgsHMap "mean(symbol)" args -> IO SymbolHandle+mean name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mean"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_mean(symbol)" = '[]++_backward_mean ::+               forall args . Fullfilled "_backward_mean(symbol)" args =>+                 String -> ArgsHMap "_backward_mean(symbol)" args -> IO SymbolHandle+_backward_mean name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mean"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "prod(symbol)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++prod ::+     forall args . Fullfilled "prod(symbol)" args =>+       String -> ArgsHMap "prod(symbol)" args -> IO SymbolHandle+prod name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "prod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_prod(symbol)" = '[]++_backward_prod ::+               forall args . Fullfilled "_backward_prod(symbol)" args =>+                 String -> ArgsHMap "_backward_prod(symbol)" args -> IO SymbolHandle+_backward_prod name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_prod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "nansum(symbol)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++nansum ::+       forall args . Fullfilled "nansum(symbol)" args =>+         String -> ArgsHMap "nansum(symbol)" args -> IO SymbolHandle+nansum name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "nansum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_nansum(symbol)" = '[]++_backward_nansum ::+                 forall args . Fullfilled "_backward_nansum(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_nansum(symbol)" args -> IO SymbolHandle+_backward_nansum name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_nansum"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "nanprod(symbol)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++nanprod ::+        forall args . Fullfilled "nanprod(symbol)" args =>+          String -> ArgsHMap "nanprod(symbol)" args -> IO SymbolHandle+nanprod name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "nanprod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_nanprod(symbol)" = '[]++_backward_nanprod ::+                  forall args . Fullfilled "_backward_nanprod(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_nanprod(symbol)" args -> IO SymbolHandle+_backward_nanprod name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_nanprod"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "max(symbol)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++max ::+    forall args . Fullfilled "max(symbol)" args =>+      String -> ArgsHMap "max(symbol)" args -> IO SymbolHandle+max name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "max"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_max(symbol)" = '[]++_backward_max ::+              forall args . Fullfilled "_backward_max(symbol)" args =>+                String -> ArgsHMap "_backward_max(symbol)" args -> IO SymbolHandle+_backward_max name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_max"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "min(symbol)" =+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++min ::+    forall args . Fullfilled "min(symbol)" args =>+      String -> ArgsHMap "min(symbol)" args -> IO SymbolHandle+min name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "min"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_min(symbol)" = '[]++_backward_min ::+              forall args . Fullfilled "_backward_min(symbol)" args =>+                String -> ArgsHMap "_backward_min(symbol)" args -> IO SymbolHandle+_backward_min name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_min"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_axis(symbol)" =+     '[ '("axis", AttrOpt [Int]), '("size", AttrOpt [Int]),+        '("data", AttrOpt SymbolHandle)]++broadcast_axis ::+               forall args . Fullfilled "broadcast_axis(symbol)" args =>+                 String -> ArgsHMap "broadcast_axis(symbol)" args -> IO SymbolHandle+broadcast_axis name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),+               ("size",) . showValue <$> (args !? #size :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_axis"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_to(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]++broadcast_to ::+             forall args . Fullfilled "broadcast_to(symbol)" args =>+               String -> ArgsHMap "broadcast_to(symbol)" args -> IO SymbolHandle+broadcast_to name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_to"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_broadcast_backward(symbol)" = '[]++_broadcast_backward ::+                    forall args . Fullfilled "_broadcast_backward(symbol)" args =>+                      String ->+                        ArgsHMap "_broadcast_backward(symbol)" args -> IO SymbolHandle+_broadcast_backward name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_broadcast_backward"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "broadcast_like(symbol)" =+     '[ '("lhs_axes", AttrOpt (Maybe [Int])),+        '("rhs_axes", AttrOpt (Maybe [Int])),+        '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++broadcast_like ::+               forall args . Fullfilled "broadcast_like(symbol)" args =>+                 String -> ArgsHMap "broadcast_like(symbol)" args -> IO SymbolHandle+broadcast_like name args+  = let scalarArgs+          = catMaybes+              [("lhs_axes",) . showValue <$>+                 (args !? #lhs_axes :: Maybe (Maybe [Int])),+               ("rhs_axes",) . showValue <$>+                 (args !? #rhs_axes :: Maybe (Maybe [Int]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "broadcast_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "norm(symbol)" =+     '[ '("ord", AttrOpt Int), '("axis", AttrOpt (Maybe [Int])),+        '("out_dtype",+          AttrOpt+            (Maybe+               (EnumType+                  '["float16", "float32", "float64", "int32", "int64", "int8"]))),+        '("keepdims", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++norm ::+     forall args . Fullfilled "norm(symbol)" args =>+       String -> ArgsHMap "norm(symbol)" args -> IO SymbolHandle+norm name args+  = let scalarArgs+          = catMaybes+              [("ord",) . showValue <$> (args !? #ord :: Maybe Int),+               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),+               ("out_dtype",) . showValue <$>+                 (args !? #out_dtype ::+                    Maybe+                      (Maybe+                         (EnumType+                            '["float16", "float32", "float64", "int32", "int64", "int8"]))),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "norm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_norm(symbol)" = '[]++_backward_norm ::+               forall args . Fullfilled "_backward_norm(symbol)" args =>+                 String -> ArgsHMap "_backward_norm(symbol)" args -> IO SymbolHandle+_backward_norm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_norm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "argmax(symbol)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle)]++argmax ::+       forall args . Fullfilled "argmax(symbol)" args =>+         String -> ArgsHMap "argmax(symbol)" args -> IO SymbolHandle+argmax name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmax"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "argmin(symbol)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle)]++argmin ::+       forall args . Fullfilled "argmin(symbol)" args =>+         String -> ArgsHMap "argmin(symbol)" args -> IO SymbolHandle+argmin name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmin"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "argmax_channel(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++argmax_channel ::+               forall args . Fullfilled "argmax_channel(symbol)" args =>+                 String -> ArgsHMap "argmax_channel(symbol)" args -> IO SymbolHandle+argmax_channel name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argmax_channel"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "pick(symbol)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),+        '("mode", AttrOpt (EnumType '["clip", "wrap"])),+        '("data", AttrOpt SymbolHandle), '("index", AttrOpt SymbolHandle)]++pick ::+     forall args . Fullfilled "pick(symbol)" args =>+       String -> ArgsHMap "pick(symbol)" args -> IO SymbolHandle+pick name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),+               ("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["clip", "wrap"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("index",) <$> (args !? #index :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "pick"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_pick(symbol)" = '[]++_backward_pick ::+               forall args . Fullfilled "_backward_pick(symbol)" args =>+                 String -> ArgsHMap "_backward_pick(symbol)" args -> IO SymbolHandle+_backward_pick name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_pick"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sparse_retain(symbol)" =+     '[ '("data", AttrOpt SymbolHandle),+        '("indices", AttrOpt SymbolHandle)]++_sparse_retain ::+               forall args . Fullfilled "_sparse_retain(symbol)" args =>+                 String -> ArgsHMap "_sparse_retain(symbol)" args -> IO SymbolHandle+_sparse_retain name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sparse_retain"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sparse_retain(symbol)" = '[]++_backward_sparse_retain ::+                        forall args . Fullfilled "_backward_sparse_retain(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_sparse_retain(symbol)" args -> IO SymbolHandle+_backward_sparse_retain name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sparse_retain"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_where(symbol)" =+     '[ '("condition", AttrOpt SymbolHandle),+        '("x", AttrOpt SymbolHandle), '("y", AttrOpt SymbolHandle)]++_where ::+       forall args . Fullfilled "_where(symbol)" args =>+         String -> ArgsHMap "_where(symbol)" args -> IO SymbolHandle+_where name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("condition",) <$> (args !? #condition :: Maybe SymbolHandle),+               ("x",) <$> (args !? #x :: Maybe SymbolHandle),+               ("y",) <$> (args !? #y :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "where"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_where(symbol)" = '[]++_backward_where ::+                forall args . Fullfilled "_backward_where(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_where(symbol)" args -> IO SymbolHandle+_backward_where name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_where"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "diag(symbol)" =+     '[ '("k", AttrOpt Int), '("axis1", AttrOpt Int),+        '("axis2", AttrOpt Int), '("data", AttrOpt SymbolHandle)]++diag ::+     forall args . Fullfilled "diag(symbol)" args =>+       String -> ArgsHMap "diag(symbol)" args -> IO SymbolHandle+diag name args+  = let scalarArgs+          = catMaybes+              [("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("axis1",) . showValue <$> (args !? #axis1 :: Maybe Int),+               ("axis2",) . showValue <$> (args !? #axis2 :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "diag"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_diag(symbol)" = '[]++_backward_diag ::+               forall args . Fullfilled "_backward_diag(symbol)" args =>+                 String -> ArgsHMap "_backward_diag(symbol)" args -> IO SymbolHandle+_backward_diag name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_diag"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_maximum_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_maximum_scalar ::+                forall args . Fullfilled "_maximum_scalar(symbol)" args =>+                  String ->+                    ArgsHMap "_maximum_scalar(symbol)" args -> IO SymbolHandle+_maximum_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_maximum_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_maximum_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_maximum_scalar ::+                         forall args . Fullfilled "_backward_maximum_scalar(symbol)" args =>+                           String ->+                             ArgsHMap "_backward_maximum_scalar(symbol)" args -> IO SymbolHandle+_backward_maximum_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_maximum_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_minimum_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_minimum_scalar ::+                forall args . Fullfilled "_minimum_scalar(symbol)" args =>+                  String ->+                    ArgsHMap "_minimum_scalar(symbol)" args -> IO SymbolHandle+_minimum_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_minimum_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_minimum_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_minimum_scalar ::+                         forall args . Fullfilled "_backward_minimum_scalar(symbol)" args =>+                           String ->+                             ArgsHMap "_backward_minimum_scalar(symbol)" args -> IO SymbolHandle+_backward_minimum_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_minimum_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_power_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_power_scalar ::+              forall args . Fullfilled "_power_scalar(symbol)" args =>+                String -> ArgsHMap "_power_scalar(symbol)" args -> IO SymbolHandle+_power_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_power_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_power_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_power_scalar ::+                       forall args . Fullfilled "_backward_power_scalar(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_power_scalar(symbol)" args -> IO SymbolHandle+_backward_power_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_power_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_rpower_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_rpower_scalar ::+               forall args . Fullfilled "_rpower_scalar(symbol)" args =>+                 String -> ArgsHMap "_rpower_scalar(symbol)" args -> IO SymbolHandle+_rpower_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_rpower_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_rpower_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_rpower_scalar ::+                        forall args . Fullfilled "_backward_rpower_scalar(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_rpower_scalar(symbol)" args -> IO SymbolHandle+_backward_rpower_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_rpower_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_hypot_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_hypot_scalar ::+              forall args . Fullfilled "_hypot_scalar(symbol)" args =>+                String -> ArgsHMap "_hypot_scalar(symbol)" args -> IO SymbolHandle+_hypot_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_hypot_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_hypot_scalar(symbol)" =+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_backward_hypot_scalar ::+                       forall args . Fullfilled "_backward_hypot_scalar(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_hypot_scalar(symbol)" args -> IO SymbolHandle+_backward_hypot_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_hypot_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "smooth_l1(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++smooth_l1 ::+          forall args . Fullfilled "smooth_l1(symbol)" args =>+            String -> ArgsHMap "smooth_l1(symbol)" args -> IO SymbolHandle+smooth_l1 name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "smooth_l1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_smooth_l1(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_smooth_l1 ::+                    forall args . Fullfilled "_backward_smooth_l1(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_smooth_l1(symbol)" args -> IO SymbolHandle+_backward_smooth_l1 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_smooth_l1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "topk(symbol)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("k", AttrOpt Int),+        '("ret_typ",+          AttrOpt (EnumType '["both", "indices", "mask", "value"])),+        '("is_ascend", AttrOpt Bool),+        '("dtype",+          AttrOpt+            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),+        '("data", AttrOpt SymbolHandle)]++topk ::+     forall args . Fullfilled "topk(symbol)" args =>+       String -> ArgsHMap "topk(symbol)" args -> IO SymbolHandle+topk name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("k",) . showValue <$> (args !? #k :: Maybe Int),+               ("ret_typ",) . showValue <$>+                 (args !? #ret_typ ::+                    Maybe (EnumType '["both", "indices", "mask", "value"])),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "topk"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_topk(symbol)" = '[]++_backward_topk ::+               forall args . Fullfilled "_backward_topk(symbol)" args =>+                 String -> ArgsHMap "_backward_topk(symbol)" args -> IO SymbolHandle+_backward_topk name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_topk"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sort(symbol)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle)]++sort ::+     forall args . Fullfilled "sort(symbol)" args =>+       String -> ArgsHMap "sort(symbol)" args -> IO SymbolHandle+sort name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sort"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "argsort(symbol)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),+        '("dtype",+          AttrOpt+            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),+        '("data", AttrOpt SymbolHandle)]++argsort ::+        forall args . Fullfilled "argsort(symbol)" args =>+          String -> ArgsHMap "argsort(symbol)" args -> IO SymbolHandle+argsort name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "argsort"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Reshape(symbol)" =+     '[ '("shape", AttrOpt [Int]), '("reverse", AttrOpt Bool),+        '("target_shape", AttrOpt [Int]), '("keep_highest", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle)]++_Reshape ::+         forall args . Fullfilled "_Reshape(symbol)" args =>+           String -> ArgsHMap "_Reshape(symbol)" args -> IO SymbolHandle+_Reshape name args+  = let scalarArgs+          = catMaybes+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),+               ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("keep_highest",) . showValue <$>+                 (args !? #keep_highest :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Reshape"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Flatten(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++_Flatten ::+         forall args . Fullfilled "_Flatten(symbol)" args =>+           String -> ArgsHMap "_Flatten(symbol)" args -> IO SymbolHandle+_Flatten name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Flatten"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "transpose(symbol)" =+     '[ '("axes", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]++transpose ::+          forall args . Fullfilled "transpose(symbol)" args =>+            String -> ArgsHMap "transpose(symbol)" args -> IO SymbolHandle+transpose name args+  = let scalarArgs+          = catMaybes+              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "transpose"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "expand_dims(symbol)" =+     '[ '("axis", AttrReq Int), '("data", AttrOpt SymbolHandle)]++expand_dims ::+            forall args . Fullfilled "expand_dims(symbol)" args =>+              String -> ArgsHMap "expand_dims(symbol)" args -> IO SymbolHandle+expand_dims name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "expand_dims"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "slice(symbol)" =+     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),+        '("step", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]++slice ::+      forall args . Fullfilled "slice(symbol)" args =>+        String -> ArgsHMap "slice(symbol)" args -> IO SymbolHandle+slice name args+  = let scalarArgs+          = catMaybes+              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "slice"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_slice(symbol)" = '[]++_backward_slice ::+                forall args . Fullfilled "_backward_slice(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_slice(symbol)" args -> IO SymbolHandle+_backward_slice name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_slice"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_slice_assign(symbol)" =+     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),+        '("step", AttrOpt [Int]), '("lhs", AttrOpt SymbolHandle),+        '("rhs", AttrOpt SymbolHandle)]++_slice_assign ::+              forall args . Fullfilled "_slice_assign(symbol)" args =>+                String -> ArgsHMap "_slice_assign(symbol)" args -> IO SymbolHandle+_slice_assign name args+  = let scalarArgs+          = catMaybes+              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_slice_assign"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_slice_assign_scalar(symbol)" =+     '[ '("scalar", AttrOpt Double), '("begin", AttrReq [Int]),+        '("end", AttrReq [Int]), '("step", AttrOpt [Int]),+        '("data", AttrOpt SymbolHandle)]++_slice_assign_scalar ::+                     forall args . Fullfilled "_slice_assign_scalar(symbol)" args =>+                       String ->+                         ArgsHMap "_slice_assign_scalar(symbol)" args -> IO SymbolHandle+_slice_assign_scalar name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Double),+               ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_slice_assign_scalar"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "slice_axis(symbol)" =+     '[ '("axis", AttrReq Int), '("begin", AttrReq Int),+        '("end", AttrReq (Maybe Int)), '("data", AttrOpt SymbolHandle)]++slice_axis ::+           forall args . Fullfilled "slice_axis(symbol)" args =>+             String -> ArgsHMap "slice_axis(symbol)" args -> IO SymbolHandle+slice_axis name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("begin",) . showValue <$> (args !? #begin :: Maybe Int),+               ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "slice_axis"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_slice_axis(symbol)" = '[]++_backward_slice_axis ::+                     forall args . Fullfilled "_backward_slice_axis(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_slice_axis(symbol)" args -> IO SymbolHandle+_backward_slice_axis name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_slice_axis"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "slice_like(symbol)" =+     '[ '("axes", AttrOpt [Int]), '("data", AttrOpt SymbolHandle),+        '("shape_like", AttrOpt SymbolHandle)]++slice_like ::+           forall args . Fullfilled "slice_like(symbol)" args =>+             String -> ArgsHMap "slice_like(symbol)" args -> IO SymbolHandle+slice_like name args+  = let scalarArgs+          = catMaybes+              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("shape_like",) <$> (args !? #shape_like :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "slice_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_slice_like(symbol)" = '[]++_backward_slice_like ::+                     forall args . Fullfilled "_backward_slice_like(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_slice_like(symbol)" args -> IO SymbolHandle+_backward_slice_like name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_slice_like"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "clip(symbol)" =+     '[ '("a_min", AttrReq Float), '("a_max", AttrReq Float),+        '("data", AttrOpt SymbolHandle)]++clip ::+     forall args . Fullfilled "clip(symbol)" args =>+       String -> ArgsHMap "clip(symbol)" args -> IO SymbolHandle+clip name args+  = let scalarArgs+          = catMaybes+              [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float),+               ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "clip"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_clip(symbol)" = '[]++_backward_clip ::+               forall args . Fullfilled "_backward_clip(symbol)" args =>+                 String -> ArgsHMap "_backward_clip(symbol)" args -> IO SymbolHandle+_backward_clip name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_clip"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "repeat(symbol)" =+     '[ '("repeats", AttrReq Int), '("axis", AttrOpt (Maybe Int)),+        '("data", AttrOpt SymbolHandle)]++repeat ::+       forall args . Fullfilled "repeat(symbol)" args =>+         String -> ArgsHMap "repeat(symbol)" args -> IO SymbolHandle+repeat name args+  = let scalarArgs+          = catMaybes+              [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int),+               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "repeat"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_repeat(symbol)" = '[]++_backward_repeat ::+                 forall args . Fullfilled "_backward_repeat(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_repeat(symbol)" args -> IO SymbolHandle+_backward_repeat name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_repeat"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "tile(symbol)" =+     '[ '("reps", AttrReq [Int]), '("data", AttrOpt SymbolHandle)]++tile ::+     forall args . Fullfilled "tile(symbol)" args =>+       String -> ArgsHMap "tile(symbol)" args -> IO SymbolHandle+tile name args+  = let scalarArgs+          = catMaybes+              [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tile"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_tile(symbol)" = '[]++_backward_tile ::+               forall args . Fullfilled "_backward_tile(symbol)" args =>+                 String -> ArgsHMap "_backward_tile(symbol)" args -> IO SymbolHandle+_backward_tile name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tile"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "reverse(symbol)" =+     '[ '("axis", AttrReq [Int]), '("data", AttrOpt SymbolHandle)]++reverse ::+        forall args . Fullfilled "reverse(symbol)" args =>+          String -> ArgsHMap "reverse(symbol)" args -> IO SymbolHandle+reverse name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "reverse"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_reverse(symbol)" = '[]++_backward_reverse ::+                  forall args . Fullfilled "_backward_reverse(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_reverse(symbol)" args -> IO SymbolHandle+_backward_reverse name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_reverse"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "stack(symbol)" =+     '[ '("axis", AttrOpt Int), '("num_args", AttrReq Int),+        '("data", AttrOpt [SymbolHandle])]++stack ::+      forall args . Fullfilled "stack(symbol)" args =>+        String -> ArgsHMap "stack(symbol)" args -> IO SymbolHandle+stack name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "stack"+         sym <- if hasKey args #num_args then+                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals+                  else+                  mxSymbolCreateAtomicSymbol (fromOpHandle op)+                    ("num_args" : scalarkeys)+                    (showValue (length array) : scalarvals)+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_backward_stack(symbol)" = '[]++_backward_stack ::+                forall args . Fullfilled "_backward_stack(symbol)" args =>+                  String ->+                    ArgsHMap "_backward_stack(symbol)" args -> IO SymbolHandle+_backward_stack name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_stack"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "squeeze(symbol)" =+     '[ '("axis", AttrOpt (Maybe [Int])),+        '("data", AttrOpt [SymbolHandle])]++squeeze ::+        forall args . Fullfilled "squeeze(symbol)" args =>+          String -> ArgsHMap "squeeze(symbol)" args -> IO SymbolHandle+squeeze name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "squeeze"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_backward_squeeze(symbol)" = '[]++_backward_squeeze ::+                  forall args . Fullfilled "_backward_squeeze(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_squeeze(symbol)" args -> IO SymbolHandle+_backward_squeeze name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_squeeze"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "depth_to_space(symbol)" =+     '[ '("block_size", AttrReq Int), '("data", AttrOpt SymbolHandle)]++depth_to_space ::+               forall args . Fullfilled "depth_to_space(symbol)" args =>+                 String -> ArgsHMap "depth_to_space(symbol)" args -> IO SymbolHandle+depth_to_space name args+  = let scalarArgs+          = catMaybes+              [("block_size",) . showValue <$>+                 (args !? #block_size :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "depth_to_space"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "space_to_depth(symbol)" =+     '[ '("block_size", AttrReq Int), '("data", AttrOpt SymbolHandle)]++space_to_depth ::+               forall args . Fullfilled "space_to_depth(symbol)" args =>+                 String -> ArgsHMap "space_to_depth(symbol)" args -> IO SymbolHandle+space_to_depth name args+  = let scalarArgs+          = catMaybes+              [("block_size",) . showValue <$>+                 (args !? #block_size :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "space_to_depth"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_split_v2(symbol)" =+     '[ '("indices", AttrReq [Int]), '("axis", AttrOpt Int),+        '("squeeze_axis", AttrOpt Bool), '("sections", AttrOpt Int),+        '("data", AttrOpt SymbolHandle)]++_split_v2 ::+          forall args . Fullfilled "_split_v2(symbol)" args =>+            String -> ArgsHMap "_split_v2(symbol)" args -> IO SymbolHandle+_split_v2 name args+  = let scalarArgs+          = catMaybes+              [("indices",) . showValue <$> (args !? #indices :: Maybe [Int]),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("squeeze_axis",) . showValue <$>+                 (args !? #squeeze_axis :: Maybe Bool),+               ("sections",) . showValue <$> (args !? #sections :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_split_v2"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_split_v2_backward(symbol)" = '[]++_split_v2_backward ::+                   forall args . Fullfilled "_split_v2_backward(symbol)" args =>+                     String ->+                       ArgsHMap "_split_v2_backward(symbol)" args -> IO SymbolHandle+_split_v2_backward name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_split_v2_backward"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "dot(symbol)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("forward_stype",+          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))),+        '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++dot ::+    forall args . Fullfilled "dot(symbol)" args =>+      String -> ArgsHMap "dot(symbol)" args -> IO SymbolHandle+dot name args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("forward_stype",) . showValue <$>+                 (args !? #forward_stype ::+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "dot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_dot(symbol)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("forward_stype",+          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"])))]++_backward_dot ::+              forall args . Fullfilled "_backward_dot(symbol)" args =>+                String -> ArgsHMap "_backward_dot(symbol)" args -> IO SymbolHandle+_backward_dot name args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("forward_stype",) . showValue <$>+                 (args !? #forward_stype ::+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_dot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "batch_dot(symbol)" =+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),+        '("forward_stype",+          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))),+        '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++batch_dot ::+          forall args . Fullfilled "batch_dot(symbol)" args =>+            String -> ArgsHMap "batch_dot(symbol)" args -> IO SymbolHandle+batch_dot name args+  = let scalarArgs+          = catMaybes+              [("transpose_a",) . showValue <$>+                 (args !? #transpose_a :: Maybe Bool),+               ("transpose_b",) . showValue <$>+                 (args !? #transpose_b :: Maybe Bool),+               ("forward_stype",) . showValue <$>+                 (args !? #forward_stype ::+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "batch_dot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_batch_dot(symbol)" = '[]++_backward_batch_dot ::+                    forall args . Fullfilled "_backward_batch_dot(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_batch_dot(symbol)" args -> IO SymbolHandle+_backward_batch_dot name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_batch_dot"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sin(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++sin ::+    forall args . Fullfilled "sin(symbol)" args =>+      String -> ArgsHMap "sin(symbol)" args -> IO SymbolHandle+sin name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sin"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sin(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_sin ::+              forall args . Fullfilled "_backward_sin(symbol)" args =>+                String -> ArgsHMap "_backward_sin(symbol)" args -> IO SymbolHandle+_backward_sin name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sin"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "cos(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++cos ::+    forall args . Fullfilled "cos(symbol)" args =>+      String -> ArgsHMap "cos(symbol)" args -> IO SymbolHandle+cos name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cos"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_cos(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_cos ::+              forall args . Fullfilled "_backward_cos(symbol)" args =>+                String -> ArgsHMap "_backward_cos(symbol)" args -> IO SymbolHandle+_backward_cos name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cos"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "tan(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++tan ::+    forall args . Fullfilled "tan(symbol)" args =>+      String -> ArgsHMap "tan(symbol)" args -> IO SymbolHandle+tan name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tan"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_tan(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_tan ::+              forall args . Fullfilled "_backward_tan(symbol)" args =>+                String -> ArgsHMap "_backward_tan(symbol)" args -> IO SymbolHandle+_backward_tan name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tan"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "arcsin(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++arcsin ::+       forall args . Fullfilled "arcsin(symbol)" args =>+         String -> ArgsHMap "arcsin(symbol)" args -> IO SymbolHandle+arcsin name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arcsin"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_arcsin(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_arcsin ::+                 forall args . Fullfilled "_backward_arcsin(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_arcsin(symbol)" args -> IO SymbolHandle+_backward_arcsin name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arcsin"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "arccos(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++arccos ::+       forall args . Fullfilled "arccos(symbol)" args =>+         String -> ArgsHMap "arccos(symbol)" args -> IO SymbolHandle+arccos name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arccos"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_arccos(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_arccos ::+                 forall args . Fullfilled "_backward_arccos(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_arccos(symbol)" args -> IO SymbolHandle+_backward_arccos name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arccos"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "arctan(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++arctan ::+       forall args . Fullfilled "arctan(symbol)" args =>+         String -> ArgsHMap "arctan(symbol)" args -> IO SymbolHandle+arctan name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arctan"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_arctan(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_arctan ::+                 forall args . Fullfilled "_backward_arctan(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_arctan(symbol)" args -> IO SymbolHandle+_backward_arctan name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arctan"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "degrees(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++degrees ::+        forall args . Fullfilled "degrees(symbol)" args =>+          String -> ArgsHMap "degrees(symbol)" args -> IO SymbolHandle+degrees name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "degrees"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_degrees(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_degrees ::+                  forall args . Fullfilled "_backward_degrees(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_degrees(symbol)" args -> IO SymbolHandle+_backward_degrees name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_degrees"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "radians(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++radians ::+        forall args . Fullfilled "radians(symbol)" args =>+          String -> ArgsHMap "radians(symbol)" args -> IO SymbolHandle+radians name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "radians"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_radians(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_radians ::+                  forall args . Fullfilled "_backward_radians(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_radians(symbol)" args -> IO SymbolHandle+_backward_radians name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_radians"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sinh(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++sinh ::+     forall args . Fullfilled "sinh(symbol)" args =>+       String -> ArgsHMap "sinh(symbol)" args -> IO SymbolHandle+sinh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sinh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_sinh(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_sinh ::+               forall args . Fullfilled "_backward_sinh(symbol)" args =>+                 String -> ArgsHMap "_backward_sinh(symbol)" args -> IO SymbolHandle+_backward_sinh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_sinh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "cosh(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++cosh ::+     forall args . Fullfilled "cosh(symbol)" args =>+       String -> ArgsHMap "cosh(symbol)" args -> IO SymbolHandle+cosh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "cosh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_cosh(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_cosh ::+               forall args . Fullfilled "_backward_cosh(symbol)" args =>+                 String -> ArgsHMap "_backward_cosh(symbol)" args -> IO SymbolHandle+_backward_cosh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cosh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "tanh(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++tanh ::+     forall args . Fullfilled "tanh(symbol)" args =>+       String -> ArgsHMap "tanh(symbol)" args -> IO SymbolHandle+tanh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "tanh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_tanh(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_tanh ::+               forall args . Fullfilled "_backward_tanh(symbol)" args =>+                 String -> ArgsHMap "_backward_tanh(symbol)" args -> IO SymbolHandle+_backward_tanh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_tanh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "arcsinh(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++arcsinh ::+        forall args . Fullfilled "arcsinh(symbol)" args =>+          String -> ArgsHMap "arcsinh(symbol)" args -> IO SymbolHandle+arcsinh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arcsinh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_arcsinh(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_arcsinh ::+                  forall args . Fullfilled "_backward_arcsinh(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_arcsinh(symbol)" args -> IO SymbolHandle+_backward_arcsinh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arcsinh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "arccosh(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++arccosh ::+        forall args . Fullfilled "arccosh(symbol)" args =>+          String -> ArgsHMap "arccosh(symbol)" args -> IO SymbolHandle+arccosh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arccosh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_arccosh(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_arccosh ::+                  forall args . Fullfilled "_backward_arccosh(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_arccosh(symbol)" args -> IO SymbolHandle+_backward_arccosh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arccosh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "arctanh(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++arctanh ::+        forall args . Fullfilled "arctanh(symbol)" args =>+          String -> ArgsHMap "arctanh(symbol)" args -> IO SymbolHandle+arctanh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "arctanh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_arctanh(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_backward_arctanh ::+                  forall args . Fullfilled "_backward_arctanh(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_arctanh(symbol)" args -> IO SymbolHandle+_backward_arctanh name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_arctanh"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "khatri_rao(symbol)" =+     '[ '("args", AttrOpt [SymbolHandle])]++khatri_rao ::+           forall args . Fullfilled "khatri_rao(symbol)" args =>+             String -> ArgsHMap "khatri_rao(symbol)" args -> IO SymbolHandle+khatri_rao name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "khatri_rao"+         sym <- if hasKey args #num_args then+                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals+                  else+                  mxSymbolCreateAtomicSymbol (fromOpHandle op)+                    ("num_args" : scalarkeys)+                    (showValue (length array) : scalarvals)+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_contrib_group_adagrad_update(symbol)"+     =+     '[ '("lr", AttrReq Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("epsilon", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("history", AttrOpt SymbolHandle)]++_contrib_group_adagrad_update ::+                              forall args .+                                Fullfilled "_contrib_group_adagrad_update(symbol)" args =>+                                String ->+                                  ArgsHMap "_contrib_group_adagrad_update(symbol)" args ->+                                    IO SymbolHandle+_contrib_group_adagrad_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("history",) <$> (args !? #history :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_group_adagrad_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_getnnz(symbol)" =+     '[ '("axis", AttrOpt (Maybe Int)), '("data", AttrOpt SymbolHandle)]++_contrib_getnnz ::+                forall args . Fullfilled "_contrib_getnnz(symbol)" args =>+                  String ->+                    ArgsHMap "_contrib_getnnz(symbol)" args -> IO SymbolHandle+_contrib_getnnz name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_getnnz"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_gradientmultiplier(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_contrib_gradientmultiplier ::+                            forall args .+                              Fullfilled "_contrib_gradientmultiplier(symbol)" args =>+                              String ->+                                ArgsHMap "_contrib_gradientmultiplier(symbol)" args ->+                                  IO SymbolHandle+_contrib_gradientmultiplier name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_gradientmultiplier"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_contrib_backward_gradientmultiplier(symbol)" =+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_contrib_backward_gradientmultiplier ::+                                     forall args .+                                       Fullfilled "_contrib_backward_gradientmultiplier(symbol)"+                                         args =>+                                       String ->+                                         ArgsHMap "_contrib_backward_gradientmultiplier(symbol)"+                                           args+                                           -> IO SymbolHandle+_contrib_backward_gradientmultiplier name args+  = let scalarArgs+          = catMaybes+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_backward_gradientmultiplier"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_edge_id(symbol)" =+     '[ '("data", AttrOpt SymbolHandle), '("u", AttrOpt SymbolHandle),+        '("v", AttrOpt SymbolHandle)]++_contrib_edge_id ::+                 forall args . Fullfilled "_contrib_edge_id(symbol)" args =>+                   String ->+                     ArgsHMap "_contrib_edge_id(symbol)" args -> IO SymbolHandle+_contrib_edge_id name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("u",) <$> (args !? #u :: Maybe SymbolHandle),+               ("v",) <$> (args !? #v :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_edge_id"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_dgl_adjacency(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++_contrib_dgl_adjacency ::+                       forall args . Fullfilled "_contrib_dgl_adjacency(symbol)" args =>+                         String ->+                           ArgsHMap "_contrib_dgl_adjacency(symbol)" args -> IO SymbolHandle+_contrib_dgl_adjacency name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_dgl_adjacency"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_hawkesll(symbol)" =+     '[ '("lda", AttrOpt SymbolHandle),+        '("alpha", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle),+        '("state", AttrOpt SymbolHandle), '("lags", AttrOpt SymbolHandle),+        '("marks", AttrOpt SymbolHandle),+        '("valid_length", AttrOpt SymbolHandle),+        '("max_time", AttrOpt SymbolHandle)]++_contrib_hawkesll ::+                  forall args . Fullfilled "_contrib_hawkesll(symbol)" args =>+                    String ->+                      ArgsHMap "_contrib_hawkesll(symbol)" args -> IO SymbolHandle+_contrib_hawkesll name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lda",) <$> (args !? #lda :: Maybe SymbolHandle),+               ("alpha",) <$> (args !? #alpha :: Maybe SymbolHandle),+               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle),+               ("state",) <$> (args !? #state :: Maybe SymbolHandle),+               ("lags",) <$> (args !? #lags :: Maybe SymbolHandle),+               ("marks",) <$> (args !? #marks :: Maybe SymbolHandle),+               ("valid_length",) <$>+                 (args !? #valid_length :: Maybe SymbolHandle),+               ("max_time",) <$> (args !? #max_time :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_hawkesll"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_backward_hawkesll(symbol)" =+     '[]++_contrib_backward_hawkesll ::+                           forall args .+                             Fullfilled "_contrib_backward_hawkesll(symbol)" args =>+                             String ->+                               ArgsHMap "_contrib_backward_hawkesll(symbol)" args ->+                                 IO SymbolHandle+_contrib_backward_hawkesll name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_backward_hawkesll"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_mp_adamw_update(symbol)" =+     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),+        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float),+        '("wd", AttrOpt Float), '("eta", AttrReq Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("mean", AttrOpt SymbolHandle), '("var", AttrOpt SymbolHandle),+        '("weight32", AttrOpt SymbolHandle),+        '("rescale_grad", AttrOpt SymbolHandle)]++_mp_adamw_update ::+                 forall args . Fullfilled "_mp_adamw_update(symbol)" args =>+                   String ->+                     ArgsHMap "_mp_adamw_update(symbol)" args -> IO SymbolHandle+_mp_adamw_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("eta",) . showValue <$> (args !? #eta :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("mean",) <$> (args !? #mean :: Maybe SymbolHandle),+               ("var",) <$> (args !? #var :: Maybe SymbolHandle),+               ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle),+               ("rescale_grad",) <$>+                 (args !? #rescale_grad :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_mp_adamw_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_adamw_update(symbol)" =+     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),+        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float),+        '("wd", AttrOpt Float), '("eta", AttrReq Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("mean", AttrOpt SymbolHandle), '("var", AttrOpt SymbolHandle),+        '("rescale_grad", AttrOpt SymbolHandle)]++_adamw_update ::+              forall args . Fullfilled "_adamw_update(symbol)" args =>+                String -> ArgsHMap "_adamw_update(symbol)" args -> IO SymbolHandle+_adamw_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("eta",) . showValue <$> (args !? #eta :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("mean",) <$> (args !? #mean :: Maybe SymbolHandle),+               ("var",) <$> (args !? #var :: Maybe SymbolHandle),+               ("rescale_grad",) <$>+                 (args !? #rescale_grad :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_adamw_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_quadratic(symbol)" =+     '[ '("a", AttrOpt Float), '("b", AttrOpt Float),+        '("c", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_contrib_quadratic ::+                   forall args . Fullfilled "_contrib_quadratic(symbol)" args =>+                     String ->+                       ArgsHMap "_contrib_quadratic(symbol)" args -> IO SymbolHandle+_contrib_quadratic name args+  = let scalarArgs+          = catMaybes+              [("a",) . showValue <$> (args !? #a :: Maybe Float),+               ("b",) . showValue <$> (args !? #b :: Maybe Float),+               ("c",) . showValue <$> (args !? #c :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quadratic"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_backward_quadratic(symbol)" =+     '[]++_contrib_backward_quadratic ::+                            forall args .+                              Fullfilled "_contrib_backward_quadratic(symbol)" args =>+                              String ->+                                ArgsHMap "_contrib_backward_quadratic(symbol)" args ->+                                  IO SymbolHandle+_contrib_backward_quadratic name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_backward_quadratic"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_div_sqrt_dim(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++_contrib_div_sqrt_dim ::+                      forall args . Fullfilled "_contrib_div_sqrt_dim(symbol)" args =>+                        String ->+                          ArgsHMap "_contrib_div_sqrt_dim(symbol)" args -> IO SymbolHandle+_contrib_div_sqrt_dim name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_div_sqrt_dim"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "multi_all_finite(symbol)" =+     '[ '("num_arrays", AttrOpt Int), '("init_output", AttrOpt Bool),+        '("data", AttrOpt [SymbolHandle])]++multi_all_finite ::+                 forall args . Fullfilled "multi_all_finite(symbol)" args =>+                   String ->+                     ArgsHMap "multi_all_finite(symbol)" args -> IO SymbolHandle+multi_all_finite name args+  = let scalarArgs+          = catMaybes+              [("num_arrays",) . showValue <$>+                 (args !? #num_arrays :: Maybe Int),+               ("init_output",) . showValue <$>+                 (args !? #init_output :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "multi_all_finite"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_contrib_index_array(symbol)" =+     '[ '("axes", AttrOpt (Maybe [Int])),+        '("data", AttrOpt SymbolHandle)]++_contrib_index_array ::+                     forall args . Fullfilled "_contrib_index_array(symbol)" args =>+                       String ->+                         ArgsHMap "_contrib_index_array(symbol)" args -> IO SymbolHandle+_contrib_index_array name args+  = let scalarArgs+          = catMaybes+              [("axes",) . showValue <$> (args !? #axes :: Maybe (Maybe [Int]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_index_array"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_index_copy(symbol)" =+     '[ '("old_tensor", AttrOpt SymbolHandle),+        '("index_vector", AttrOpt SymbolHandle),+        '("new_tensor", AttrOpt SymbolHandle)]++_contrib_index_copy ::+                    forall args . Fullfilled "_contrib_index_copy(symbol)" args =>+                      String ->+                        ArgsHMap "_contrib_index_copy(symbol)" args -> IO SymbolHandle+_contrib_index_copy name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("old_tensor",) <$> (args !? #old_tensor :: Maybe SymbolHandle),+               ("index_vector",) <$>+                 (args !? #index_vector :: Maybe SymbolHandle),+               ("new_tensor",) <$> (args !? #new_tensor :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_index_copy"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_backward_index_copy(symbol)"+     = '[]++_contrib_backward_index_copy ::+                             forall args .+                               Fullfilled "_contrib_backward_index_copy(symbol)" args =>+                               String ->+                                 ArgsHMap "_contrib_backward_index_copy(symbol)" args ->+                                   IO SymbolHandle+_contrib_backward_index_copy name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_backward_index_copy"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_ROIAlign(symbol)" =+     '[ '("pooled_size", AttrReq [Int]),+        '("spatial_scale", AttrReq Float), '("sample_ratio", AttrOpt Int),+        '("position_sensitive", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle)]++_contrib_ROIAlign ::+                  forall args . Fullfilled "_contrib_ROIAlign(symbol)" args =>+                    String ->+                      ArgsHMap "_contrib_ROIAlign(symbol)" args -> IO SymbolHandle+_contrib_ROIAlign name args+  = let scalarArgs+          = catMaybes+              [("pooled_size",) . showValue <$>+                 (args !? #pooled_size :: Maybe [Int]),+               ("spatial_scale",) . showValue <$>+                 (args !? #spatial_scale :: Maybe Float),+               ("sample_ratio",) . showValue <$>+                 (args !? #sample_ratio :: Maybe Int),+               ("position_sensitive",) . showValue <$>+                 (args !? #position_sensitive :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_ROIAlign"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_ROIAlign(symbol)" = '[]++_backward_ROIAlign ::+                   forall args . Fullfilled "_backward_ROIAlign(symbol)" args =>+                     String ->+                       ArgsHMap "_backward_ROIAlign(symbol)" args -> IO SymbolHandle+_backward_ROIAlign name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_ROIAlign"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_box_nms(symbol)" =+     '[ '("overlap_thresh", AttrOpt Float),+        '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int),+        '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int),+        '("id_index", AttrOpt Int), '("background_id", AttrOpt Int),+        '("force_suppress", AttrOpt Bool),+        '("in_format", AttrOpt (EnumType '["center", "corner"])),+        '("out_format", AttrOpt (EnumType '["center", "corner"])),+        '("data", AttrOpt SymbolHandle)]++_contrib_box_nms ::+                 forall args . Fullfilled "_contrib_box_nms(symbol)" args =>+                   String ->+                     ArgsHMap "_contrib_box_nms(symbol)" args -> IO SymbolHandle+_contrib_box_nms name args+  = let scalarArgs+          = catMaybes+              [("overlap_thresh",) . showValue <$>+                 (args !? #overlap_thresh :: Maybe Float),+               ("valid_thresh",) . showValue <$>+                 (args !? #valid_thresh :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),+               ("coord_start",) . showValue <$>+                 (args !? #coord_start :: Maybe Int),+               ("score_index",) . showValue <$>+                 (args !? #score_index :: Maybe Int),+               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),+               ("background_id",) . showValue <$>+                 (args !? #background_id :: Maybe Int),+               ("force_suppress",) . showValue <$>+                 (args !? #force_suppress :: Maybe Bool),+               ("in_format",) . showValue <$>+                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),+               ("out_format",) . showValue <$>+                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_box_nms"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_contrib_box_nms(symbol)" =+     '[ '("overlap_thresh", AttrOpt Float),+        '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int),+        '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int),+        '("id_index", AttrOpt Int), '("background_id", AttrOpt Int),+        '("force_suppress", AttrOpt Bool),+        '("in_format", AttrOpt (EnumType '["center", "corner"])),+        '("out_format", AttrOpt (EnumType '["center", "corner"]))]++_backward_contrib_box_nms ::+                          forall args .+                            Fullfilled "_backward_contrib_box_nms(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_contrib_box_nms(symbol)" args ->+                                IO SymbolHandle+_backward_contrib_box_nms name args+  = let scalarArgs+          = catMaybes+              [("overlap_thresh",) . showValue <$>+                 (args !? #overlap_thresh :: Maybe Float),+               ("valid_thresh",) . showValue <$>+                 (args !? #valid_thresh :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),+               ("coord_start",) . showValue <$>+                 (args !? #coord_start :: Maybe Int),+               ("score_index",) . showValue <$>+                 (args !? #score_index :: Maybe Int),+               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),+               ("background_id",) . showValue <$>+                 (args !? #background_id :: Maybe Int),+               ("force_suppress",) . showValue <$>+                 (args !? #force_suppress :: Maybe Bool),+               ("in_format",) . showValue <$>+                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),+               ("out_format",) . showValue <$>+                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_box_nms"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_box_iou(symbol)" =+     '[ '("format", AttrOpt (EnumType '["center", "corner"])),+        '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]++_contrib_box_iou ::+                 forall args . Fullfilled "_contrib_box_iou(symbol)" args =>+                   String ->+                     ArgsHMap "_contrib_box_iou(symbol)" args -> IO SymbolHandle+_contrib_box_iou name args+  = let scalarArgs+          = catMaybes+              [("format",) . showValue <$>+                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_box_iou"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_contrib_box_iou(symbol)" =+     '[ '("format", AttrOpt (EnumType '["center", "corner"]))]++_backward_contrib_box_iou ::+                          forall args .+                            Fullfilled "_backward_contrib_box_iou(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_contrib_box_iou(symbol)" args ->+                                IO SymbolHandle+_backward_contrib_box_iou name args+  = let scalarArgs+          = catMaybes+              [("format",) . showValue <$>+                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_box_iou"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_bipartite_matching(symbol)" =+     '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float),+        '("topk", AttrOpt Int), '("data", AttrOpt SymbolHandle)]++_contrib_bipartite_matching ::+                            forall args .+                              Fullfilled "_contrib_bipartite_matching(symbol)" args =>+                              String ->+                                ArgsHMap "_contrib_bipartite_matching(symbol)" args ->+                                  IO SymbolHandle+_contrib_bipartite_matching name args+  = let scalarArgs+          = catMaybes+              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_bipartite_matching"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward_contrib_bipartite_matching(symbol)" =+     '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float),+        '("topk", AttrOpt Int)]++_backward_contrib_bipartite_matching ::+                                     forall args .+                                       Fullfilled "_backward_contrib_bipartite_matching(symbol)"+                                         args =>+                                       String ->+                                         ArgsHMap "_backward_contrib_bipartite_matching(symbol)"+                                           args+                                           -> IO SymbolHandle+_backward_contrib_bipartite_matching name args+  = let scalarArgs+          = catMaybes+              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_bipartite_matching"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_BilinearResize2D(symbol)" =+     '[ '("height", AttrOpt Int), '("width", AttrOpt Int),+        '("scale_height", AttrOpt (Maybe Float)),+        '("scale_width", AttrOpt (Maybe Float)),+        '("mode",+          AttrOpt+            (EnumType+               '["like", "odd_scale", "size", "to_even_down", "to_even_up",+                 "to_odd_down", "to_odd_up"])),+        '("data", AttrOpt SymbolHandle), '("like", AttrOpt SymbolHandle)]++_contrib_BilinearResize2D ::+                          forall args .+                            Fullfilled "_contrib_BilinearResize2D(symbol)" args =>+                            String ->+                              ArgsHMap "_contrib_BilinearResize2D(symbol)" args ->+                                IO SymbolHandle+_contrib_BilinearResize2D name args+  = let scalarArgs+          = catMaybes+              [("height",) . showValue <$> (args !? #height :: Maybe Int),+               ("width",) . showValue <$> (args !? #width :: Maybe Int),+               ("scale_height",) . showValue <$>+                 (args !? #scale_height :: Maybe (Maybe Float)),+               ("scale_width",) . showValue <$>+                 (args !? #scale_width :: Maybe (Maybe Float)),+               ("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe+                      (EnumType+                         '["like", "odd_scale", "size", "to_even_down", "to_even_up",+                           "to_odd_down", "to_odd_up"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("like",) <$> (args !? #like :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_BilinearResize2D"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward_contrib_BilinearResize2D(symbol)" = '[]++_backward_contrib_BilinearResize2D ::+                                   forall args .+                                     Fullfilled "_backward_contrib_BilinearResize2D(symbol)" args =>+                                     String ->+                                       ArgsHMap "_backward_contrib_BilinearResize2D(symbol)" args ->+                                         IO SymbolHandle+_backward_contrib_BilinearResize2D name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_BilinearResize2D"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_boolean_mask(symbol)" =+     '[ '("axis", AttrOpt Int), '("data", AttrOpt SymbolHandle),+        '("index", AttrOpt SymbolHandle)]++_contrib_boolean_mask ::+                      forall args . Fullfilled "_contrib_boolean_mask(symbol)" args =>+                        String ->+                          ArgsHMap "_contrib_boolean_mask(symbol)" args -> IO SymbolHandle+_contrib_boolean_mask name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("index",) <$> (args !? #index :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_boolean_mask"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward_contrib_boolean_mask(symbol)" =+     '[ '("axis", AttrOpt Int)]++_backward_contrib_boolean_mask ::+                               forall args .+                                 Fullfilled "_backward_contrib_boolean_mask(symbol)" args =>+                                 String ->+                                   ArgsHMap "_backward_contrib_boolean_mask(symbol)" args ->+                                     IO SymbolHandle+_backward_contrib_boolean_mask name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_boolean_mask"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_SyncBatchNorm(symbol)" =+     '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float),+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),+        '("output_mean_var", AttrOpt Bool), '("ndev", AttrOpt Int),+        '("key", AttrReq String), '("data", AttrOpt SymbolHandle),+        '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle),+        '("moving_mean", AttrOpt SymbolHandle),+        '("moving_var", AttrOpt SymbolHandle)]++_contrib_SyncBatchNorm ::+                       forall args . Fullfilled "_contrib_SyncBatchNorm(symbol)" args =>+                         String ->+                           ArgsHMap "_contrib_SyncBatchNorm(symbol)" args -> IO SymbolHandle+_contrib_SyncBatchNorm name args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool),+               ("ndev",) . showValue <$> (args !? #ndev :: Maybe Int),+               ("key",) . showValue <$> (args !? #key :: Maybe String)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),+               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle),+               ("moving_mean",) <$> (args !? #moving_mean :: Maybe SymbolHandle),+               ("moving_var",) <$> (args !? #moving_var :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_SyncBatchNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_AdaptiveAvgPooling2D(symbol)"+     =+     '[ '("output_size", AttrOpt [Int]),+        '("data", AttrOpt SymbolHandle)]++_contrib_AdaptiveAvgPooling2D ::+                              forall args .+                                Fullfilled "_contrib_AdaptiveAvgPooling2D(symbol)" args =>+                                String ->+                                  ArgsHMap "_contrib_AdaptiveAvgPooling2D(symbol)" args ->+                                    IO SymbolHandle+_contrib_AdaptiveAvgPooling2D name args+  = let scalarArgs+          = catMaybes+              [("output_size",) . showValue <$>+                 (args !? #output_size :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_AdaptiveAvgPooling2D"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward_contrib_AdaptiveAvgPooling2D(symbol)" =+     '[]++_backward_contrib_AdaptiveAvgPooling2D ::+                                       forall args .+                                         Fullfilled "_backward_contrib_AdaptiveAvgPooling2D(symbol)"+                                           args =>+                                         String ->+                                           ArgsHMap "_backward_contrib_AdaptiveAvgPooling2D(symbol)"+                                             args+                                             -> IO SymbolHandle+_backward_contrib_AdaptiveAvgPooling2D name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_contrib_AdaptiveAvgPooling2D"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_crop(symbol)" =+     '[ '("x", AttrReq Int), '("y", AttrReq Int),+        '("width", AttrReq Int), '("height", AttrReq Int),+        '("data", AttrOpt SymbolHandle)]++_image_crop ::+            forall args . Fullfilled "_image_crop(symbol)" args =>+              String -> ArgsHMap "_image_crop(symbol)" args -> IO SymbolHandle+_image_crop name args+  = let scalarArgs+          = catMaybes+              [("x",) . showValue <$> (args !? #x :: Maybe Int),+               ("y",) . showValue <$> (args !? #y :: Maybe Int),+               ("width",) . showValue <$> (args !? #width :: Maybe Int),+               ("height",) . showValue <$> (args !? #height :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_crop"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_image_crop(symbol)" = '[]++_backward_image_crop ::+                     forall args . Fullfilled "_backward_image_crop(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_image_crop(symbol)" args -> IO SymbolHandle+_backward_image_crop name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_image_crop"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_to_tensor(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++_image_to_tensor ::+                 forall args . Fullfilled "_image_to_tensor(symbol)" args =>+                   String ->+                     ArgsHMap "_image_to_tensor(symbol)" args -> IO SymbolHandle+_image_to_tensor name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_to_tensor"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_normalize(symbol)" =+     '[ '("mean", AttrOpt [Float]), '("std", AttrOpt [Float]),+        '("data", AttrOpt SymbolHandle)]++_image_normalize ::+                 forall args . Fullfilled "_image_normalize(symbol)" args =>+                   String ->+                     ArgsHMap "_image_normalize(symbol)" args -> IO SymbolHandle+_image_normalize name args+  = let scalarArgs+          = catMaybes+              [("mean",) . showValue <$> (args !? #mean :: Maybe [Float]),+               ("std",) . showValue <$> (args !? #std :: Maybe [Float])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_normalize"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_image_normalize(symbol)" =+     '[]++_backward_image_normalize ::+                          forall args .+                            Fullfilled "_backward_image_normalize(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_image_normalize(symbol)" args ->+                                IO SymbolHandle+_backward_image_normalize name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_image_normalize"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_flip_left_right(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++_image_flip_left_right ::+                       forall args . Fullfilled "_image_flip_left_right(symbol)" args =>+                         String ->+                           ArgsHMap "_image_flip_left_right(symbol)" args -> IO SymbolHandle+_image_flip_left_right name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_flip_left_right"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_random_flip_left_right(symbol)"+     = '[ '("data", AttrOpt SymbolHandle)]++_image_random_flip_left_right ::+                              forall args .+                                Fullfilled "_image_random_flip_left_right(symbol)" args =>+                                String ->+                                  ArgsHMap "_image_random_flip_left_right(symbol)" args ->+                                    IO SymbolHandle+_image_random_flip_left_right name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_flip_left_right"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_flip_top_bottom(symbol)" =+     '[ '("data", AttrOpt SymbolHandle)]++_image_flip_top_bottom ::+                       forall args . Fullfilled "_image_flip_top_bottom(symbol)" args =>+                         String ->+                           ArgsHMap "_image_flip_top_bottom(symbol)" args -> IO SymbolHandle+_image_flip_top_bottom name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_flip_top_bottom"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_random_flip_top_bottom(symbol)"+     = '[ '("data", AttrOpt SymbolHandle)]++_image_random_flip_top_bottom ::+                              forall args .+                                Fullfilled "_image_random_flip_top_bottom(symbol)" args =>+                                String ->+                                  ArgsHMap "_image_random_flip_top_bottom(symbol)" args ->+                                    IO SymbolHandle+_image_random_flip_top_bottom name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_flip_top_bottom"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_random_brightness(symbol)" =+     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),+        '("data", AttrOpt SymbolHandle)]++_image_random_brightness ::+                         forall args . Fullfilled "_image_random_brightness(symbol)" args =>+                           String ->+                             ArgsHMap "_image_random_brightness(symbol)" args -> IO SymbolHandle+_image_random_brightness name args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_brightness"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_random_contrast(symbol)" =+     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),+        '("data", AttrOpt SymbolHandle)]++_image_random_contrast ::+                       forall args . Fullfilled "_image_random_contrast(symbol)" args =>+                         String ->+                           ArgsHMap "_image_random_contrast(symbol)" args -> IO SymbolHandle+_image_random_contrast name args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_contrast"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_random_saturation(symbol)" =+     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),+        '("data", AttrOpt SymbolHandle)]++_image_random_saturation ::+                         forall args . Fullfilled "_image_random_saturation(symbol)" args =>+                           String ->+                             ArgsHMap "_image_random_saturation(symbol)" args -> IO SymbolHandle+_image_random_saturation name args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_saturation"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_random_hue(symbol)" =+     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),+        '("data", AttrOpt SymbolHandle)]++_image_random_hue ::+                  forall args . Fullfilled "_image_random_hue(symbol)" args =>+                    String ->+                      ArgsHMap "_image_random_hue(symbol)" args -> IO SymbolHandle+_image_random_hue name args+  = let scalarArgs+          = catMaybes+              [("min_factor",) . showValue <$>+                 (args !? #min_factor :: Maybe Float),+               ("max_factor",) . showValue <$>+                 (args !? #max_factor :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_hue"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_random_color_jitter(symbol)" =+     '[ '("brightness", AttrReq Float), '("contrast", AttrReq Float),+        '("saturation", AttrReq Float), '("hue", AttrReq Float),+        '("data", AttrOpt SymbolHandle)]++_image_random_color_jitter ::+                           forall args .+                             Fullfilled "_image_random_color_jitter(symbol)" args =>+                             String ->+                               ArgsHMap "_image_random_color_jitter(symbol)" args ->+                                 IO SymbolHandle+_image_random_color_jitter name args+  = let scalarArgs+          = catMaybes+              [("brightness",) . showValue <$>+                 (args !? #brightness :: Maybe Float),+               ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float),+               ("saturation",) . showValue <$>+                 (args !? #saturation :: Maybe Float),+               ("hue",) . showValue <$> (args !? #hue :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_color_jitter"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_adjust_lighting(symbol)" =+     '[ '("alpha", AttrReq [Float]), '("data", AttrOpt SymbolHandle)]++_image_adjust_lighting ::+                       forall args . Fullfilled "_image_adjust_lighting(symbol)" args =>+                         String ->+                           ArgsHMap "_image_adjust_lighting(symbol)" args -> IO SymbolHandle+_image_adjust_lighting name args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe [Float])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_adjust_lighting"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_random_lighting(symbol)" =+     '[ '("alpha_std", AttrOpt Float), '("data", AttrOpt SymbolHandle)]++_image_random_lighting ::+                       forall args . Fullfilled "_image_random_lighting(symbol)" args =>+                         String ->+                           ArgsHMap "_image_random_lighting(symbol)" args -> IO SymbolHandle+_image_random_lighting name args+  = let scalarArgs+          = catMaybes+              [("alpha_std",) . showValue <$>+                 (args !? #alpha_std :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_random_lighting"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_image_resize(symbol)" =+     '[ '("size", AttrOpt [Int]), '("keep_ratio", AttrOpt Bool),+        '("interp", AttrOpt Int), '("data", AttrOpt SymbolHandle)]++_image_resize ::+              forall args . Fullfilled "_image_resize(symbol)" args =>+                String -> ArgsHMap "_image_resize(symbol)" args -> IO SymbolHandle+_image_resize name args+  = let scalarArgs+          = catMaybes+              [("size",) . showValue <$> (args !? #size :: Maybe [Int]),+               ("keep_ratio",) . showValue <$>+                 (args !? #keep_ratio :: Maybe Bool),+               ("interp",) . showValue <$> (args !? #interp :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_image_resize"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "moments(symbol)" =+     '[ '("axes", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle)]++moments ::+        forall args . Fullfilled "moments(symbol)" args =>+          String -> ArgsHMap "moments(symbol)" args -> IO SymbolHandle+moments name args+  = let scalarArgs+          = catMaybes+              [("axes",) . showValue <$> (args !? #axes :: Maybe (Maybe [Int])),+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "moments"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_moments(symbol)" = '[]++_backward_moments ::+                  forall args . Fullfilled "_backward_moments(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_moments(symbol)" args -> IO SymbolHandle+_backward_moments name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_moments"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "softmax(symbol)" =+     '[ '("axis", AttrOpt Int),+        '("temperature", AttrOpt (Maybe Double)),+        '("dtype",+          AttrOpt (Maybe (EnumType '["float16", "float32", "float64"]))),+        '("data", AttrOpt SymbolHandle)]++softmax ::+        forall args . Fullfilled "softmax(symbol)" args =>+          String -> ArgsHMap "softmax(symbol)" args -> IO SymbolHandle+softmax name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("temperature",) . showValue <$>+                 (args !? #temperature :: Maybe (Maybe Double)),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (Maybe (EnumType '["float16", "float32", "float64"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softmax"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_softmax(symbol)" =+     '[ '("args", AttrOpt [SymbolHandle])]++_backward_softmax ::+                  forall args . Fullfilled "_backward_softmax(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_softmax(symbol)" args -> IO SymbolHandle+_backward_softmax name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "_backward_softmax"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "softmin(symbol)" =+     '[ '("axis", AttrOpt Int),+        '("temperature", AttrOpt (Maybe Double)),+        '("dtype",+          AttrOpt (Maybe (EnumType '["float16", "float32", "float64"]))),+        '("data", AttrOpt SymbolHandle)]++softmin ::+        forall args . Fullfilled "softmin(symbol)" args =>+          String -> ArgsHMap "softmin(symbol)" args -> IO SymbolHandle+softmin name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("temperature",) . showValue <$>+                 (args !? #temperature :: Maybe (Maybe Double)),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (Maybe (EnumType '["float16", "float32", "float64"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softmin"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_softmin(symbol)" =+     '[ '("args", AttrOpt [SymbolHandle])]++_backward_softmin ::+                  forall args . Fullfilled "_backward_softmin(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_softmin(symbol)" args -> IO SymbolHandle+_backward_softmin name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "_backward_softmin"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "log_softmax(symbol)" =+     '[ '("axis", AttrOpt Int),+        '("temperature", AttrOpt (Maybe Double)),+        '("dtype",+          AttrOpt (Maybe (EnumType '["float16", "float32", "float64"]))),+        '("data", AttrOpt SymbolHandle)]++log_softmax ::+            forall args . Fullfilled "log_softmax(symbol)" args =>+              String -> ArgsHMap "log_softmax(symbol)" args -> IO SymbolHandle+log_softmax name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("temperature",) . showValue <$>+                 (args !? #temperature :: Maybe (Maybe Double)),+               ("dtype",) . showValue <$>+                 (args !? #dtype ::+                    Maybe (Maybe (EnumType '["float16", "float32", "float64"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "log_softmax"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_log_softmax(symbol)" =+     '[ '("args", AttrOpt [SymbolHandle])]++_backward_log_softmax ::+                      forall args . Fullfilled "_backward_log_softmax(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_log_softmax(symbol)" args -> IO SymbolHandle+_backward_log_softmax name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "_backward_log_softmax"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_Pooling(symbol)" =+     '[ '("kernel", AttrOpt [Int]),+        '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])),+        '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool),+        '("pooling_convention",+          AttrOpt (EnumType '["full", "same", "valid"])),+        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("p_value", AttrOpt (Maybe Int)),+        '("count_include_pad", AttrOpt (Maybe Bool)),+        '("layout",+          AttrOpt+            (Maybe+               (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"]))),+        '("data", AttrOpt SymbolHandle)]++_Pooling ::+         forall args . Fullfilled "_Pooling(symbol)" args =>+           String -> ArgsHMap "_Pooling(symbol)" args -> IO SymbolHandle+_Pooling name args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("pool_type",) . showValue <$>+                 (args !? #pool_type ::+                    Maybe (EnumType '["avg", "lp", "max", "sum"])),+               ("global_pool",) . showValue <$>+                 (args !? #global_pool :: Maybe Bool),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("pooling_convention",) . showValue <$>+                 (args !? #pooling_convention ::+                    Maybe (EnumType '["full", "same", "valid"])),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("p_value",) . showValue <$>+                 (args !? #p_value :: Maybe (Maybe Int)),+               ("count_include_pad",) . showValue <$>+                 (args !? #count_include_pad :: Maybe (Maybe Bool)),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe+                         (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Pooling(symbol)" = '[]++_backward_Pooling ::+                  forall args . Fullfilled "_backward_Pooling(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_Pooling(symbol)" args -> IO SymbolHandle+_backward_Pooling name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Deconvolution(symbol)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("adj", AttrOpt [Int]), '("target_shape", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("cudnn_tune",+          AttrOpt+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+        '("cudnn_off", AttrOpt Bool),+        '("layout",+          AttrOpt+            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),+        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),+        '("bias", AttrOpt SymbolHandle)]++_Deconvolution ::+               forall args . Fullfilled "_Deconvolution(symbol)" args =>+                 String -> ArgsHMap "_Deconvolution(symbol)" args -> IO SymbolHandle+_Deconvolution name args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Deconvolution"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Deconvolution(symbol)" = '[]++_backward_Deconvolution ::+                        forall args . Fullfilled "_backward_Deconvolution(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_Deconvolution(symbol)" args -> IO SymbolHandle+_backward_Deconvolution name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Deconvolution"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Activation(symbol)" =+     '[ '("act_type",+          AttrReq+            (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"])),+        '("data", AttrOpt SymbolHandle)]++_Activation ::+            forall args . Fullfilled "_Activation(symbol)" args =>+              String -> ArgsHMap "_Activation(symbol)" args -> IO SymbolHandle+_Activation name args+  = let scalarArgs+          = catMaybes+              [("act_type",) . showValue <$>+                 (args !? #act_type ::+                    Maybe+                      (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Activation"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Activation(symbol)" = '[]++_backward_Activation ::+                     forall args . Fullfilled "_backward_Activation(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_Activation(symbol)" args -> IO SymbolHandle+_backward_Activation name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Activation"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_UpSampling(symbol)" =+     '[ '("scale", AttrReq Int), '("num_filter", AttrOpt Int),+        '("sample_type", AttrReq (EnumType '["bilinear", "nearest"])),+        '("multi_input_mode", AttrOpt (EnumType '["concat", "sum"])),+        '("num_args", AttrReq Int), '("workspace", AttrOpt Int),+        '("data", AttrOpt [SymbolHandle])]++_UpSampling ::+            forall args . Fullfilled "_UpSampling(symbol)" args =>+              String -> ArgsHMap "_UpSampling(symbol)" args -> IO SymbolHandle+_UpSampling name args+  = let scalarArgs+          = catMaybes+              [("scale",) . showValue <$> (args !? #scale :: Maybe Int),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("sample_type",) . showValue <$>+                 (args !? #sample_type ::+                    Maybe (EnumType '["bilinear", "nearest"])),+               ("multi_input_mode",) . showValue <$>+                 (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])),+               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "UpSampling"+         sym <- if hasKey args #num_args then+                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals+                  else+                  mxSymbolCreateAtomicSymbol (fromOpHandle op)+                    ("num_args" : scalarkeys)+                    (showValue (length array) : scalarvals)+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_backward_UpSampling(symbol)" = '[]++_backward_UpSampling ::+                     forall args . Fullfilled "_backward_UpSampling(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_UpSampling(symbol)" args -> IO SymbolHandle+_backward_UpSampling name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_UpSampling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_BatchNorm(symbol)" =+     '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float),+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),+        '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int),+        '("cudnn_off", AttrOpt Bool), '("data", AttrOpt SymbolHandle),+        '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle),+        '("moving_mean", AttrOpt SymbolHandle),+        '("moving_var", AttrOpt SymbolHandle)]++_BatchNorm ::+           forall args . Fullfilled "_BatchNorm(symbol)" args =>+             String -> ArgsHMap "_BatchNorm(symbol)" args -> IO SymbolHandle+_BatchNorm name args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),+               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle),+               ("moving_mean",) <$> (args !? #moving_mean :: Maybe SymbolHandle),+               ("moving_var",) <$> (args !? #moving_var :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BatchNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_BatchNorm(symbol)" = '[]++_backward_BatchNorm ::+                    forall args . Fullfilled "_backward_BatchNorm(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_BatchNorm(symbol)" args -> IO SymbolHandle+_backward_BatchNorm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BatchNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_CTCLoss(symbol)" =+     '[ '("use_data_lengths", AttrOpt Bool),+        '("use_label_lengths", AttrOpt Bool),+        '("blank_label", AttrOpt (EnumType '["first", "last"])),+        '("data", AttrOpt SymbolHandle), '("label", AttrOpt SymbolHandle),+        '("data_lengths", AttrOpt SymbolHandle),+        '("label_lengths", AttrOpt SymbolHandle)]++_CTCLoss ::+         forall args . Fullfilled "_CTCLoss(symbol)" args =>+           String -> ArgsHMap "_CTCLoss(symbol)" args -> IO SymbolHandle+_CTCLoss name args+  = let scalarArgs+          = catMaybes+              [("use_data_lengths",) . showValue <$>+                 (args !? #use_data_lengths :: Maybe Bool),+               ("use_label_lengths",) . showValue <$>+                 (args !? #use_label_lengths :: Maybe Bool),+               ("blank_label",) . showValue <$>+                 (args !? #blank_label :: Maybe (EnumType '["first", "last"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle),+               ("data_lengths",) <$>+                 (args !? #data_lengths :: Maybe SymbolHandle),+               ("label_lengths",) <$>+                 (args !? #label_lengths :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "CTCLoss"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_ctc_loss(symbol)" = '[]++_backward_ctc_loss ::+                   forall args . Fullfilled "_backward_ctc_loss(symbol)" args =>+                     String ->+                       ArgsHMap "_backward_ctc_loss(symbol)" args -> IO SymbolHandle+_backward_ctc_loss name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_ctc_loss"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_FullyConnected(symbol)" =+     '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool),+        '("flatten", AttrOpt Bool), '("data", AttrOpt SymbolHandle),+        '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle)]++_FullyConnected ::+                forall args . Fullfilled "_FullyConnected(symbol)" args =>+                  String ->+                    ArgsHMap "_FullyConnected(symbol)" args -> IO SymbolHandle+_FullyConnected name args+  = let scalarArgs+          = catMaybes+              [("num_hidden",) . showValue <$>+                 (args !? #num_hidden :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "FullyConnected"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_FullyConnected(symbol)" =+     '[]++_backward_FullyConnected ::+                         forall args . Fullfilled "_backward_FullyConnected(symbol)" args =>+                           String ->+                             ArgsHMap "_backward_FullyConnected(symbol)" args -> IO SymbolHandle+_backward_FullyConnected name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_FullyConnected"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Convolution(symbol)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("cudnn_tune",+          AttrOpt+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+        '("cudnn_off", AttrOpt Bool),+        '("layout",+          AttrOpt+            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),+        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),+        '("bias", AttrOpt SymbolHandle)]++_Convolution ::+             forall args . Fullfilled "_Convolution(symbol)" args =>+               String -> ArgsHMap "_Convolution(symbol)" args -> IO SymbolHandle+_Convolution name args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Convolution"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Convolution(symbol)" = '[]++_backward_Convolution ::+                      forall args . Fullfilled "_backward_Convolution(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_Convolution(symbol)" args -> IO SymbolHandle+_backward_Convolution name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Convolution"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_LayerNorm(symbol)" =+     '[ '("axis", AttrOpt Int), '("eps", AttrOpt Float),+        '("output_mean_var", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle), '("gamma", AttrOpt SymbolHandle),+        '("beta", AttrOpt SymbolHandle)]++_LayerNorm ::+           forall args . Fullfilled "_LayerNorm(symbol)" args =>+             String -> ArgsHMap "_LayerNorm(symbol)" args -> IO SymbolHandle+_LayerNorm name args+  = let scalarArgs+          = catMaybes+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),+               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LayerNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_LayerNorm(symbol)" = '[]++_backward_LayerNorm ::+                    forall args . Fullfilled "_backward_LayerNorm(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_LayerNorm(symbol)" args -> IO SymbolHandle+_backward_LayerNorm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LayerNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Concat(symbol)" =+     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),+        '("data", AttrOpt [SymbolHandle])]++_Concat ::+        forall args . Fullfilled "_Concat(symbol)" args =>+          String -> ArgsHMap "_Concat(symbol)" args -> IO SymbolHandle+_Concat name args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "Concat"+         sym <- if hasKey args #num_args then+                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals+                  else+                  mxSymbolCreateAtomicSymbol (fromOpHandle op)+                    ("num_args" : scalarkeys)+                    (showValue (length array) : scalarvals)+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_backward_Concat(symbol)" = '[]++_backward_Concat ::+                 forall args . Fullfilled "_backward_Concat(symbol)" args =>+                   String ->+                     ArgsHMap "_backward_Concat(symbol)" args -> IO SymbolHandle+_backward_Concat name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Concat"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_rnn_param_concat(symbol)" =+     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),+        '("data", AttrOpt [SymbolHandle])]++_rnn_param_concat ::+                  forall args . Fullfilled "_rnn_param_concat(symbol)" args =>+                    String ->+                      ArgsHMap "_rnn_param_concat(symbol)" args -> IO SymbolHandle+_rnn_param_concat name args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "_rnn_param_concat"+         sym <- if hasKey args #num_args then+                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals+                  else+                  mxSymbolCreateAtomicSymbol (fromOpHandle op)+                    ("num_args" : scalarkeys)+                    (showValue (length array) : scalarvals)+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_SoftmaxActivation(symbol)" =+     '[ '("mode", AttrOpt (EnumType '["channel", "instance"])),+        '("data", AttrOpt SymbolHandle)]++_SoftmaxActivation ::+                   forall args . Fullfilled "_SoftmaxActivation(symbol)" args =>+                     String ->+                       ArgsHMap "_SoftmaxActivation(symbol)" args -> IO SymbolHandle+_SoftmaxActivation name args+  = let scalarArgs+          = catMaybes+              [("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["channel", "instance"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SoftmaxActivation"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SoftmaxActivation(symbol)" =+     '[]++_backward_SoftmaxActivation ::+                            forall args .+                              Fullfilled "_backward_SoftmaxActivation(symbol)" args =>+                              String ->+                                ArgsHMap "_backward_SoftmaxActivation(symbol)" args ->+                                  IO SymbolHandle+_backward_SoftmaxActivation name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SoftmaxActivation"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_LRN(symbol)" =+     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),+        '("knorm", AttrOpt Float), '("nsize", AttrReq Int),+        '("data", AttrOpt SymbolHandle)]++_LRN ::+     forall args . Fullfilled "_LRN(symbol)" args =>+       String -> ArgsHMap "_LRN(symbol)" args -> IO SymbolHandle+_LRN name args+  = let scalarArgs+          = catMaybes+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float),+               ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LRN"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_LRN(symbol)" = '[]++_backward_LRN ::+              forall args . Fullfilled "_backward_LRN(symbol)" args =>+                String -> ArgsHMap "_backward_LRN(symbol)" args -> IO SymbolHandle+_backward_LRN name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LRN"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Dropout(symbol)" =+     '[ '("p", AttrOpt Float),+        '("mode", AttrOpt (EnumType '["always", "training"])),+        '("axes", AttrOpt [Int]), '("cudnn_off", AttrOpt (Maybe Bool)),+        '("data", AttrOpt SymbolHandle)]++_Dropout ::+         forall args . Fullfilled "_Dropout(symbol)" args =>+           String -> ArgsHMap "_Dropout(symbol)" args -> IO SymbolHandle+_Dropout name args+  = let scalarArgs+          = catMaybes+              [("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("mode",) . showValue <$>+                 (args !? #mode :: Maybe (EnumType '["always", "training"])),+               ("axes",) . showValue <$> (args !? #axes :: Maybe [Int]),+               ("cudnn_off",) . showValue <$>+                 (args !? #cudnn_off :: Maybe (Maybe Bool))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Dropout"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Dropout(symbol)" = '[]++_backward_Dropout ::+                  forall args . Fullfilled "_backward_Dropout(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_Dropout(symbol)" args -> IO SymbolHandle+_backward_Dropout name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Dropout"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_contrib_quantized_elemwise_add(symbol)" =+     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle),+        '("lhs_min", AttrOpt SymbolHandle),+        '("lhs_max", AttrOpt SymbolHandle),+        '("rhs_min", AttrOpt SymbolHandle),+        '("rhs_max", AttrOpt SymbolHandle)]++_contrib_quantized_elemwise_add ::+                                forall args .+                                  Fullfilled "_contrib_quantized_elemwise_add(symbol)" args =>+                                  String ->+                                    ArgsHMap "_contrib_quantized_elemwise_add(symbol)" args ->+                                      IO SymbolHandle+_contrib_quantized_elemwise_add name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),+               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle),+               ("lhs_min",) <$> (args !? #lhs_min :: Maybe SymbolHandle),+               ("lhs_max",) <$> (args !? #lhs_max :: Maybe SymbolHandle),+               ("rhs_min",) <$> (args !? #rhs_min :: Maybe SymbolHandle),+               ("rhs_max",) <$> (args !? #rhs_max :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_elemwise_add"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_dequantize(symbol)" =+     '[ '("out_type", AttrOpt (EnumType '["float32"])),+        '("data", AttrOpt SymbolHandle),+        '("min_range", AttrOpt SymbolHandle),+        '("max_range", AttrOpt SymbolHandle)]++_contrib_dequantize ::+                    forall args . Fullfilled "_contrib_dequantize(symbol)" args =>+                      String ->+                        ArgsHMap "_contrib_dequantize(symbol)" args -> IO SymbolHandle+_contrib_dequantize name args+  = let scalarArgs+          = catMaybes+              [("out_type",) . showValue <$>+                 (args !? #out_type :: Maybe (EnumType '["float32"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle),+               ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_dequantize"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_quantized_flatten(symbol)" =+     '[ '("data", AttrOpt SymbolHandle),+        '("min_data", AttrOpt SymbolHandle),+        '("max_data", AttrOpt SymbolHandle)]++_contrib_quantized_flatten ::+                           forall args .+                             Fullfilled "_contrib_quantized_flatten(symbol)" args =>+                             String ->+                               ArgsHMap "_contrib_quantized_flatten(symbol)" args ->+                                 IO SymbolHandle+_contrib_quantized_flatten name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_flatten"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_quantized_conv(symbol)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("cudnn_tune",+          AttrOpt+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+        '("cudnn_off", AttrOpt Bool),+        '("layout",+          AttrOpt+            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),+        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),+        '("bias", AttrOpt SymbolHandle),+        '("min_data", AttrOpt SymbolHandle),+        '("max_data", AttrOpt SymbolHandle),+        '("min_weight", AttrOpt SymbolHandle),+        '("max_weight", AttrOpt SymbolHandle),+        '("min_bias", AttrOpt SymbolHandle),+        '("max_bias", AttrOpt SymbolHandle)]++_contrib_quantized_conv ::+                        forall args . Fullfilled "_contrib_quantized_conv(symbol)" args =>+                          String ->+                            ArgsHMap "_contrib_quantized_conv(symbol)" args -> IO SymbolHandle+_contrib_quantized_conv name args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle),+               ("min_weight",) <$> (args !? #min_weight :: Maybe SymbolHandle),+               ("max_weight",) <$> (args !? #max_weight :: Maybe SymbolHandle),+               ("min_bias",) <$> (args !? #min_bias :: Maybe SymbolHandle),+               ("max_bias",) <$> (args !? #max_bias :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_conv"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_contrib_quantized_fully_connected(symbol)" =+     '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool),+        '("flatten", AttrOpt Bool), '("data", AttrOpt SymbolHandle),+        '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle),+        '("min_data", AttrOpt SymbolHandle),+        '("max_data", AttrOpt SymbolHandle),+        '("min_weight", AttrOpt SymbolHandle),+        '("max_weight", AttrOpt SymbolHandle),+        '("min_bias", AttrOpt SymbolHandle),+        '("max_bias", AttrOpt SymbolHandle)]++_contrib_quantized_fully_connected ::+                                   forall args .+                                     Fullfilled "_contrib_quantized_fully_connected(symbol)" args =>+                                     String ->+                                       ArgsHMap "_contrib_quantized_fully_connected(symbol)" args ->+                                         IO SymbolHandle+_contrib_quantized_fully_connected name args+  = let scalarArgs+          = catMaybes+              [("num_hidden",) . showValue <$>+                 (args !? #num_hidden :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle),+               ("min_weight",) <$> (args !? #min_weight :: Maybe SymbolHandle),+               ("max_weight",) <$> (args !? #max_weight :: Maybe SymbolHandle),+               ("min_bias",) <$> (args !? #min_bias :: Maybe SymbolHandle),+               ("max_bias",) <$> (args !? #max_bias :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_fully_connected"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_quantized_pooling(symbol)" =+     '[ '("kernel", AttrOpt [Int]),+        '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])),+        '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool),+        '("pooling_convention",+          AttrOpt (EnumType '["full", "same", "valid"])),+        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("p_value", AttrOpt (Maybe Int)),+        '("count_include_pad", AttrOpt (Maybe Bool)),+        '("layout",+          AttrOpt+            (Maybe+               (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"]))),+        '("data", AttrOpt SymbolHandle),+        '("min_data", AttrOpt SymbolHandle),+        '("max_data", AttrOpt SymbolHandle)]++_contrib_quantized_pooling ::+                           forall args .+                             Fullfilled "_contrib_quantized_pooling(symbol)" args =>+                             String ->+                               ArgsHMap "_contrib_quantized_pooling(symbol)" args ->+                                 IO SymbolHandle+_contrib_quantized_pooling name args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("pool_type",) . showValue <$>+                 (args !? #pool_type ::+                    Maybe (EnumType '["avg", "lp", "max", "sum"])),+               ("global_pool",) . showValue <$>+                 (args !? #global_pool :: Maybe Bool),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("pooling_convention",) . showValue <$>+                 (args !? #pooling_convention ::+                    Maybe (EnumType '["full", "same", "valid"])),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("p_value",) . showValue <$>+                 (args !? #p_value :: Maybe (Maybe Int)),+               ("count_include_pad",) . showValue <$>+                 (args !? #count_include_pad :: Maybe (Maybe Bool)),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe+                      (Maybe+                         (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_pooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_quantize_v2(symbol)" =+     '[ '("out_type", AttrOpt (EnumType '["auto", "int8", "uint8"])),+        '("min_calib_range", AttrOpt (Maybe Float)),+        '("max_calib_range", AttrOpt (Maybe Float)),+        '("data", AttrOpt SymbolHandle)]++_contrib_quantize_v2 ::+                     forall args . Fullfilled "_contrib_quantize_v2(symbol)" args =>+                       String ->+                         ArgsHMap "_contrib_quantize_v2(symbol)" args -> IO SymbolHandle+_contrib_quantize_v2 name args+  = let scalarArgs+          = catMaybes+              [("out_type",) . showValue <$>+                 (args !? #out_type :: Maybe (EnumType '["auto", "int8", "uint8"])),+               ("min_calib_range",) . showValue <$>+                 (args !? #min_calib_range :: Maybe (Maybe Float)),+               ("max_calib_range",) . showValue <$>+                 (args !? #max_calib_range :: Maybe (Maybe Float))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantize_v2"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_quantized_concat(symbol)" =+     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),+        '("data", AttrOpt [SymbolHandle])]++_contrib_quantized_concat ::+                          forall args .+                            Fullfilled "_contrib_quantized_concat(symbol)" args =>+                            String ->+                              ArgsHMap "_contrib_quantized_concat(symbol)" args ->+                                IO SymbolHandle+_contrib_quantized_concat name args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "_contrib_quantized_concat"+         sym <- if hasKey args #num_args then+                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals+                  else+                  mxSymbolCreateAtomicSymbol (fromOpHandle op)+                    ("num_args" : scalarkeys)+                    (showValue (length array) : scalarvals)+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_contrib_requantize(symbol)" =+     '[ '("out_type", AttrOpt (EnumType '["auto", "int8", "uint8"])),+        '("min_calib_range", AttrOpt (Maybe Float)),+        '("max_calib_range", AttrOpt (Maybe Float)),+        '("data", AttrOpt SymbolHandle),+        '("min_range", AttrOpt SymbolHandle),+        '("max_range", AttrOpt SymbolHandle)]++_contrib_requantize ::+                    forall args . Fullfilled "_contrib_requantize(symbol)" args =>+                      String ->+                        ArgsHMap "_contrib_requantize(symbol)" args -> IO SymbolHandle+_contrib_requantize name args+  = let scalarArgs+          = catMaybes+              [("out_type",) . showValue <$>+                 (args !? #out_type :: Maybe (EnumType '["auto", "int8", "uint8"])),+               ("min_calib_range",) . showValue <$>+                 (args !? #min_calib_range :: Maybe (Maybe Float)),+               ("max_calib_range",) . showValue <$>+                 (args !? #max_calib_range :: Maybe (Maybe Float))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle),+               ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_requantize"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_quantized_act(symbol)" =+     '[ '("act_type",+          AttrReq+            (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"])),+        '("data", AttrOpt SymbolHandle),+        '("min_data", AttrOpt SymbolHandle),+        '("max_data", AttrOpt SymbolHandle)]++_contrib_quantized_act ::+                       forall args . Fullfilled "_contrib_quantized_act(symbol)" args =>+                         String ->+                           ArgsHMap "_contrib_quantized_act(symbol)" args -> IO SymbolHandle+_contrib_quantized_act name args+  = let scalarArgs+          = catMaybes+              [("act_type",) . showValue <$>+                 (args !? #act_type ::+                    Maybe+                      (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle),+               ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantized_act"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_quantize(symbol)" =+     '[ '("out_type", AttrOpt (EnumType '["int8", "uint8"])),+        '("data", AttrOpt SymbolHandle),+        '("min_range", AttrOpt SymbolHandle),+        '("max_range", AttrOpt SymbolHandle)]++_contrib_quantize ::+                  forall args . Fullfilled "_contrib_quantize(symbol)" args =>+                    String ->+                      ArgsHMap "_contrib_quantize(symbol)" args -> IO SymbolHandle+_contrib_quantize name args+  = let scalarArgs+          = catMaybes+              [("out_type",) . showValue <$>+                 (args !? #out_type :: Maybe (EnumType '["int8", "uint8"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle),+               ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_quantize"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_cvimread(symbol)" =+     '[ '("filename", AttrReq String), '("flag", AttrOpt Int),+        '("to_rgb", AttrOpt Bool)]++_cvimread ::+          forall args . Fullfilled "_cvimread(symbol)" args =>+            String -> ArgsHMap "_cvimread(symbol)" args -> IO SymbolHandle+_cvimread name args+  = let scalarArgs+          = catMaybes+              [("filename",) . showValue <$> (args !? #filename :: Maybe String),+               ("flag",) . showValue <$> (args !? #flag :: Maybe Int),+               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_cvimread"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_NoGradient(symbol)" = '[]++_NoGradient ::+            forall args . Fullfilled "_NoGradient(symbol)" args =>+              String -> ArgsHMap "_NoGradient(symbol)" args -> IO SymbolHandle+_NoGradient name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_NoGradient"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_CachedOp(symbol)" =+     '[ '("data", AttrOpt [SymbolHandle])]++_CachedOp ::+          forall args . Fullfilled "_CachedOp(symbol)" args =>+            String -> ArgsHMap "_CachedOp(symbol)" args -> IO SymbolHandle+_CachedOp name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "_CachedOp"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_backward_CachedOp(symbol)" = '[]++_backward_CachedOp ::+                   forall args . Fullfilled "_backward_CachedOp(symbol)" args =>+                     String ->+                       ArgsHMap "_backward_CachedOp(symbol)" args -> IO SymbolHandle+_backward_CachedOp name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_CachedOp"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "softmax_cross_entropy(symbol)" =+     '[ '("data", AttrOpt SymbolHandle),+        '("label", AttrOpt SymbolHandle)]++softmax_cross_entropy ::+                      forall args . Fullfilled "softmax_cross_entropy(symbol)" args =>+                        String ->+                          ArgsHMap "softmax_cross_entropy(symbol)" args -> IO SymbolHandle+softmax_cross_entropy name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "softmax_cross_entropy"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward_softmax_cross_entropy(symbol)" = '[]++_backward_softmax_cross_entropy ::+                                forall args .+                                  Fullfilled "_backward_softmax_cross_entropy(symbol)" args =>+                                  String ->+                                    ArgsHMap "_backward_softmax_cross_entropy(symbol)" args ->+                                      IO SymbolHandle+_backward_softmax_cross_entropy name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_softmax_cross_entropy"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_foreach(symbol)" = '[]++_backward_foreach ::+                  forall args . Fullfilled "_backward_foreach(symbol)" args =>+                    String ->+                      ArgsHMap "_backward_foreach(symbol)" args -> IO SymbolHandle+_backward_foreach name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_foreach"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_while_loop(symbol)" = '[]++_backward_while_loop ::+                     forall args . Fullfilled "_backward_while_loop(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_while_loop(symbol)" args -> IO SymbolHandle+_backward_while_loop name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_while_loop"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_cond(symbol)" = '[]++_backward_cond ::+               forall args . Fullfilled "_backward_cond(symbol)" args =>+                 String -> ArgsHMap "_backward_cond(symbol)" args -> IO SymbolHandle+_backward_cond name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_cond"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SoftmaxOutput(symbol)" =+     '[ '("grad_scale", AttrOpt Float),+        '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool),+        '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool),+        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),+        '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float),+        '("data", AttrOpt SymbolHandle), '("label", AttrOpt SymbolHandle)]++_SoftmaxOutput ::+               forall args . Fullfilled "_SoftmaxOutput(symbol)" args =>+                 String -> ArgsHMap "_SoftmaxOutput(symbol)" args -> IO SymbolHandle+_SoftmaxOutput name args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float),+               ("ignore_label",) . showValue <$>+                 (args !? #ignore_label :: Maybe Float),+               ("multi_output",) . showValue <$>+                 (args !? #multi_output :: Maybe Bool),+               ("use_ignore",) . showValue <$>+                 (args !? #use_ignore :: Maybe Bool),+               ("preserve_shape",) . showValue <$>+                 (args !? #preserve_shape :: Maybe Bool),+               ("normalization",) . showValue <$>+                 (args !? #normalization ::+                    Maybe (EnumType '["batch", "null", "valid"])),+               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),+               ("smooth_alpha",) . showValue <$>+                 (args !? #smooth_alpha :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SoftmaxOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SoftmaxOutput(symbol)" = '[]++_backward_SoftmaxOutput ::+                        forall args . Fullfilled "_backward_SoftmaxOutput(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_SoftmaxOutput(symbol)" args -> IO SymbolHandle+_backward_SoftmaxOutput name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SoftmaxOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_LeakyReLU(symbol)" =+     '[ '("act_type",+          AttrOpt+            (EnumType '["elu", "gelu", "leaky", "prelu", "rrelu", "selu"])),+        '("slope", AttrOpt Float), '("lower_bound", AttrOpt Float),+        '("upper_bound", AttrOpt Float), '("data", AttrOpt SymbolHandle),+        '("gamma", AttrOpt SymbolHandle)]++_LeakyReLU ::+           forall args . Fullfilled "_LeakyReLU(symbol)" args =>+             String -> ArgsHMap "_LeakyReLU(symbol)" args -> IO SymbolHandle+_LeakyReLU name args+  = let scalarArgs+          = catMaybes+              [("act_type",) . showValue <$>+                 (args !? #act_type ::+                    Maybe+                      (EnumType '["elu", "gelu", "leaky", "prelu", "rrelu", "selu"])),+               ("slope",) . showValue <$> (args !? #slope :: Maybe Float),+               ("lower_bound",) . showValue <$>+                 (args !? #lower_bound :: Maybe Float),+               ("upper_bound",) . showValue <$>+                 (args !? #upper_bound :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LeakyReLU"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SwapAxis(symbol)" =+     '[ '("dim1", AttrOpt Int), '("dim2", AttrOpt Int),+        '("data", AttrOpt SymbolHandle)]++_SwapAxis ::+          forall args . Fullfilled "_SwapAxis(symbol)" args =>+            String -> ArgsHMap "_SwapAxis(symbol)" args -> IO SymbolHandle+_SwapAxis name args+  = let scalarArgs+          = catMaybes+              [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int),+               ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SwapAxis"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_IdentityAttachKLSparseReg(symbol)" =+     '[ '("sparseness_target", AttrOpt Float),+        '("penalty", AttrOpt Float), '("momentum", AttrOpt Float),+        '("data", AttrOpt SymbolHandle)]++_IdentityAttachKLSparseReg ::+                           forall args .+                             Fullfilled "_IdentityAttachKLSparseReg(symbol)" args =>+                             String ->+                               ArgsHMap "_IdentityAttachKLSparseReg(symbol)" args ->+                                 IO SymbolHandle+_IdentityAttachKLSparseReg name args+  = let scalarArgs+          = catMaybes+              [("sparseness_target",) . showValue <$>+                 (args !? #sparseness_target :: Maybe Float),+               ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "IdentityAttachKLSparseReg"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SliceChannel(symbol)" =+     '[ '("num_outputs", AttrReq Int), '("axis", AttrOpt Int),+        '("squeeze_axis", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]++_SliceChannel ::+              forall args . Fullfilled "_SliceChannel(symbol)" args =>+                String -> ArgsHMap "_SliceChannel(symbol)" args -> IO SymbolHandle+_SliceChannel name args+  = let scalarArgs+          = catMaybes+              [("num_outputs",) . showValue <$>+                 (args !? #num_outputs :: Maybe Int),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),+               ("squeeze_axis",) . showValue <$>+                 (args !? #squeeze_axis :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SliceChannel"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_RNN(symbol)" =+     '[ '("state_size", AttrReq Int), '("num_layers", AttrReq Int),+        '("bidirectional", AttrOpt Bool),+        '("mode",+          AttrReq (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),+        '("p", AttrOpt Float), '("state_outputs", AttrOpt Bool),+        '("projection_size", AttrOpt (Maybe Int)),+        '("lstm_state_clip_min", AttrOpt (Maybe Double)),+        '("lstm_state_clip_max", AttrOpt (Maybe Double)),+        '("lstm_state_clip_nan", AttrOpt Bool),+        '("use_sequence_length", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle),+        '("parameters", AttrOpt SymbolHandle),+        '("state", AttrOpt SymbolHandle),+        '("state_cell", AttrOpt SymbolHandle),+        '("sequence_length", AttrOpt SymbolHandle)]++_RNN ::+     forall args . Fullfilled "_RNN(symbol)" args =>+       String -> ArgsHMap "_RNN(symbol)" args -> IO SymbolHandle+_RNN name args+  = let scalarArgs+          = catMaybes+              [("state_size",) . showValue <$>+                 (args !? #state_size :: Maybe Int),+               ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int),+               ("bidirectional",) . showValue <$>+                 (args !? #bidirectional :: Maybe Bool),+               ("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),+               ("p",) . showValue <$> (args !? #p :: Maybe Float),+               ("state_outputs",) . showValue <$>+                 (args !? #state_outputs :: Maybe Bool),+               ("projection_size",) . showValue <$>+                 (args !? #projection_size :: Maybe (Maybe Int)),+               ("lstm_state_clip_min",) . showValue <$>+                 (args !? #lstm_state_clip_min :: Maybe (Maybe Double)),+               ("lstm_state_clip_max",) . showValue <$>+                 (args !? #lstm_state_clip_max :: Maybe (Maybe Double)),+               ("lstm_state_clip_nan",) . showValue <$>+                 (args !? #lstm_state_clip_nan :: Maybe Bool),+               ("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("parameters",) <$> (args !? #parameters :: Maybe SymbolHandle),+               ("state",) <$> (args !? #state :: Maybe SymbolHandle),+               ("state_cell",) <$> (args !? #state_cell :: Maybe SymbolHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "RNN"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_RNN(symbol)" = '[]++_backward_RNN ::+              forall args . Fullfilled "_backward_RNN(symbol)" args =>+                String -> ArgsHMap "_backward_RNN(symbol)" args -> IO SymbolHandle+_backward_RNN name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_RNN"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Pad(symbol)" =+     '[ '("mode", AttrReq (EnumType '["constant", "edge", "reflect"])),+        '("pad_width", AttrReq [Int]), '("constant_value", AttrOpt Double),+        '("data", AttrOpt SymbolHandle)]++_Pad ::+     forall args . Fullfilled "_Pad(symbol)" args =>+       String -> ArgsHMap "_Pad(symbol)" args -> IO SymbolHandle+_Pad name args+  = let scalarArgs+          = catMaybes+              [("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["constant", "edge", "reflect"])),+               ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]),+               ("constant_value",) . showValue <$>+                 (args !? #constant_value :: Maybe Double)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pad"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_BatchNorm_v1(symbol)" =+     '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float),+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),+        '("output_mean_var", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle), '("gamma", AttrOpt SymbolHandle),+        '("beta", AttrOpt SymbolHandle)]++_BatchNorm_v1 ::+              forall args . Fullfilled "_BatchNorm_v1(symbol)" args =>+                String -> ArgsHMap "_BatchNorm_v1(symbol)" args -> IO SymbolHandle+_BatchNorm_v1 name args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),+               ("use_global_stats",) . showValue <$>+                 (args !? #use_global_stats :: Maybe Bool),+               ("output_mean_var",) . showValue <$>+                 (args !? #output_mean_var :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),+               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BatchNorm_v1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "signsgd_update(symbol)" =+     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle)]++signsgd_update ::+               forall args . Fullfilled "signsgd_update(symbol)" args =>+                 String -> ArgsHMap "signsgd_update(symbol)" args -> IO SymbolHandle+signsgd_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "signsgd_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "signum_update(symbol)" =+     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("wd_lh", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("mom", AttrOpt SymbolHandle)]++signum_update ::+              forall args . Fullfilled "signum_update(symbol)" args =>+                String -> ArgsHMap "signum_update(symbol)" args -> IO SymbolHandle+signum_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("wd_lh",) . showValue <$> (args !? #wd_lh :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("mom",) <$> (args !? #mom :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "signum_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "multi_sgd_update(symbol)" =+     '[ '("lrs", AttrReq [Float]), '("wds", AttrReq [Float]),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int),+        '("data", AttrOpt [SymbolHandle])]++multi_sgd_update ::+                 forall args . Fullfilled "multi_sgd_update(symbol)" args =>+                   String ->+                     ArgsHMap "multi_sgd_update(symbol)" args -> IO SymbolHandle+multi_sgd_update name args+  = let scalarArgs+          = catMaybes+              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),+               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("num_weights",) . showValue <$>+                 (args !? #num_weights :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "multi_sgd_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "multi_sgd_mom_update(symbol)" =+     '[ '("lrs", AttrReq [Float]), '("wds", AttrReq [Float]),+        '("momentum", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int),+        '("data", AttrOpt [SymbolHandle])]++multi_sgd_mom_update ::+                     forall args . Fullfilled "multi_sgd_mom_update(symbol)" args =>+                       String ->+                         ArgsHMap "multi_sgd_mom_update(symbol)" args -> IO SymbolHandle+multi_sgd_mom_update name args+  = let scalarArgs+          = catMaybes+              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),+               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("num_weights",) . showValue <$>+                 (args !? #num_weights :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "multi_sgd_mom_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "multi_mp_sgd_update(symbol)" =+     '[ '("lrs", AttrReq [Float]), '("wds", AttrReq [Float]),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int),+        '("data", AttrOpt [SymbolHandle])]++multi_mp_sgd_update ::+                    forall args . Fullfilled "multi_mp_sgd_update(symbol)" args =>+                      String ->+                        ArgsHMap "multi_mp_sgd_update(symbol)" args -> IO SymbolHandle+multi_mp_sgd_update name args+  = let scalarArgs+          = catMaybes+              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),+               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("num_weights",) . showValue <$>+                 (args !? #num_weights :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "multi_mp_sgd_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "multi_mp_sgd_mom_update(symbol)" =+     '[ '("lrs", AttrReq [Float]), '("wds", AttrReq [Float]),+        '("momentum", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int),+        '("data", AttrOpt [SymbolHandle])]++multi_mp_sgd_mom_update ::+                        forall args . Fullfilled "multi_mp_sgd_mom_update(symbol)" args =>+                          String ->+                            ArgsHMap "multi_mp_sgd_mom_update(symbol)" args -> IO SymbolHandle+multi_mp_sgd_mom_update name args+  = let scalarArgs+          = catMaybes+              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),+               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("num_weights",) . showValue <$>+                 (args !? #num_weights :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "multi_mp_sgd_mom_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "sgd_update(symbol)" =+     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle)]++sgd_update ::+           forall args . Fullfilled "sgd_update(symbol)" args =>+             String -> ArgsHMap "sgd_update(symbol)" args -> IO SymbolHandle+sgd_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sgd_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "sgd_mom_update(symbol)" =+     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("mom", AttrOpt SymbolHandle)]++sgd_mom_update ::+               forall args . Fullfilled "sgd_mom_update(symbol)" args =>+                 String -> ArgsHMap "sgd_mom_update(symbol)" args -> IO SymbolHandle+sgd_mom_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("mom",) <$> (args !? #mom :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "sgd_mom_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "mp_sgd_update(symbol)" =+     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("weight32", AttrOpt SymbolHandle)]++mp_sgd_update ::+              forall args . Fullfilled "mp_sgd_update(symbol)" args =>+                String -> ArgsHMap "mp_sgd_update(symbol)" args -> IO SymbolHandle+mp_sgd_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mp_sgd_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "mp_sgd_mom_update(symbol)" =+     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("mom", AttrOpt SymbolHandle),+        '("weight32", AttrOpt SymbolHandle)]++mp_sgd_mom_update ::+                  forall args . Fullfilled "mp_sgd_mom_update(symbol)" args =>+                    String ->+                      ArgsHMap "mp_sgd_mom_update(symbol)" args -> IO SymbolHandle+mp_sgd_mom_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("mom",) <$> (args !? #mom :: Maybe SymbolHandle),+               ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mp_sgd_mom_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "ftml_update(symbol)" =+     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),+        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Double),+        '("t", AttrReq Int), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float), '("clip_grad", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("d", AttrOpt SymbolHandle), '("v", AttrOpt SymbolHandle),+        '("z", AttrOpt SymbolHandle)]++ftml_update ::+            forall args . Fullfilled "ftml_update(symbol)" args =>+              String -> ArgsHMap "ftml_update(symbol)" args -> IO SymbolHandle+ftml_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Double),+               ("t",) . showValue <$> (args !? #t :: Maybe Int),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_grad",) . showValue <$> (args !? #clip_grad :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("d",) <$> (args !? #d :: Maybe SymbolHandle),+               ("v",) <$> (args !? #v :: Maybe SymbolHandle),+               ("z",) <$> (args !? #z :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ftml_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "adam_update(symbol)" =+     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),+        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("mean", AttrOpt SymbolHandle), '("var", AttrOpt SymbolHandle)]++adam_update ::+            forall args . Fullfilled "adam_update(symbol)" args =>+              String -> ArgsHMap "adam_update(symbol)" args -> IO SymbolHandle+adam_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("lazy_update",) . showValue <$>+                 (args !? #lazy_update :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("mean",) <$> (args !? #mean :: Maybe SymbolHandle),+               ("var",) <$> (args !? #var :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "adam_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "nag_mom_update(symbol)" =+     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("mom", AttrOpt SymbolHandle)]++nag_mom_update ::+               forall args . Fullfilled "nag_mom_update(symbol)" args =>+                 String -> ArgsHMap "nag_mom_update(symbol)" args -> IO SymbolHandle+nag_mom_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("mom",) <$> (args !? #mom :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "nag_mom_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "mp_nag_mom_update(symbol)" =+     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("mom", AttrOpt SymbolHandle),+        '("weight32", AttrOpt SymbolHandle)]++mp_nag_mom_update ::+                  forall args . Fullfilled "mp_nag_mom_update(symbol)" args =>+                    String ->+                      ArgsHMap "mp_nag_mom_update(symbol)" args -> IO SymbolHandle+mp_nag_mom_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("mom",) <$> (args !? #mom :: Maybe SymbolHandle),+               ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "mp_nag_mom_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "rmsprop_update(symbol)" =+     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),+        '("epsilon", AttrOpt Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("clip_weights", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("n", AttrOpt SymbolHandle)]++rmsprop_update ::+               forall args . Fullfilled "rmsprop_update(symbol)" args =>+                 String -> ArgsHMap "rmsprop_update(symbol)" args -> IO SymbolHandle+rmsprop_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("clip_weights",) . showValue <$>+                 (args !? #clip_weights :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("n",) <$> (args !? #n :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rmsprop_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "rmspropalex_update(symbol)" =+     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),+        '("gamma2", AttrOpt Float), '("epsilon", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("clip_weights", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("n", AttrOpt SymbolHandle), '("g", AttrOpt SymbolHandle),+        '("delta", AttrOpt SymbolHandle)]++rmspropalex_update ::+                   forall args . Fullfilled "rmspropalex_update(symbol)" args =>+                     String ->+                       ArgsHMap "rmspropalex_update(symbol)" args -> IO SymbolHandle+rmspropalex_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),+               ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float),+               ("clip_weights",) . showValue <$>+                 (args !? #clip_weights :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("n",) <$> (args !? #n :: Maybe SymbolHandle),+               ("g",) <$> (args !? #g :: Maybe SymbolHandle),+               ("delta",) <$> (args !? #delta :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "rmspropalex_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "ftrl_update(symbol)" =+     '[ '("lr", AttrReq Float), '("lamda1", AttrOpt Float),+        '("beta", AttrOpt Float), '("wd", AttrOpt Float),+        '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("z", AttrOpt SymbolHandle), '("n", AttrOpt SymbolHandle)]++ftrl_update ::+            forall args . Fullfilled "ftrl_update(symbol)" args =>+              String -> ArgsHMap "ftrl_update(symbol)" args -> IO SymbolHandle+ftrl_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float),+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("z",) <$> (args !? #z :: Maybe SymbolHandle),+               ("n",) <$> (args !? #n :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ftrl_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_sparse_adagrad_update(symbol)" =+     '[ '("lr", AttrReq Float), '("epsilon", AttrOpt Float),+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),+        '("clip_gradient", AttrOpt Float),+        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),+        '("history", AttrOpt SymbolHandle)]++_sparse_adagrad_update ::+                       forall args . Fullfilled "_sparse_adagrad_update(symbol)" args =>+                         String ->+                           ArgsHMap "_sparse_adagrad_update(symbol)" args -> IO SymbolHandle+_sparse_adagrad_update name args+  = let scalarArgs+          = catMaybes+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),+               ("rescale_grad",) . showValue <$>+                 (args !? #rescale_grad :: Maybe Float),+               ("clip_gradient",) . showValue <$>+                 (args !? #clip_gradient :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),+               ("history",) <$> (args !? #history :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_sparse_adagrad_update"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_LinearRegressionOutput(symbol)" =+     '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle),+        '("label", AttrOpt SymbolHandle)]++_LinearRegressionOutput ::+                        forall args . Fullfilled "_LinearRegressionOutput(symbol)" args =>+                          String ->+                            ArgsHMap "_LinearRegressionOutput(symbol)" args -> IO SymbolHandle+_LinearRegressionOutput name args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LinearRegressionOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_linear_reg_out(symbol)" =+     '[]++_backward_linear_reg_out ::+                         forall args . Fullfilled "_backward_linear_reg_out(symbol)" args =>+                           String ->+                             ArgsHMap "_backward_linear_reg_out(symbol)" args -> IO SymbolHandle+_backward_linear_reg_out name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_linear_reg_out"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_MAERegressionOutput(symbol)" =+     '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle),+        '("label", AttrOpt SymbolHandle)]++_MAERegressionOutput ::+                     forall args . Fullfilled "_MAERegressionOutput(symbol)" args =>+                       String ->+                         ArgsHMap "_MAERegressionOutput(symbol)" args -> IO SymbolHandle+_MAERegressionOutput name args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "MAERegressionOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_mae_reg_out(symbol)" = '[]++_backward_mae_reg_out ::+                      forall args . Fullfilled "_backward_mae_reg_out(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_mae_reg_out(symbol)" args -> IO SymbolHandle+_backward_mae_reg_out name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_mae_reg_out"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_LogisticRegressionOutput(symbol)" =+     '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle),+        '("label", AttrOpt SymbolHandle)]++_LogisticRegressionOutput ::+                          forall args .+                            Fullfilled "_LogisticRegressionOutput(symbol)" args =>+                            String ->+                              ArgsHMap "_LogisticRegressionOutput(symbol)" args ->+                                IO SymbolHandle+_LogisticRegressionOutput name args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "LogisticRegressionOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_logistic_reg_out(symbol)" =+     '[]++_backward_logistic_reg_out ::+                           forall args .+                             Fullfilled "_backward_logistic_reg_out(symbol)" args =>+                             String ->+                               ArgsHMap "_backward_logistic_reg_out(symbol)" args ->+                                 IO SymbolHandle+_backward_logistic_reg_out name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_logistic_reg_out"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_CustomFunction(symbol)" = '[]++_CustomFunction ::+                forall args . Fullfilled "_CustomFunction(symbol)" args =>+                  String ->+                    ArgsHMap "_CustomFunction(symbol)" args -> IO SymbolHandle+_CustomFunction name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_CustomFunction"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_CustomFunction(symbol)" =+     '[]++_backward_CustomFunction ::+                         forall args . Fullfilled "_backward_CustomFunction(symbol)" args =>+                           String ->+                             ArgsHMap "_backward_CustomFunction(symbol)" args -> IO SymbolHandle+_backward_CustomFunction name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_CustomFunction"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward__Native(symbol)" = '[]++_backward__Native ::+                  forall args . Fullfilled "_backward__Native(symbol)" args =>+                    String ->+                      ArgsHMap "_backward__Native(symbol)" args -> IO SymbolHandle+_backward__Native name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__Native"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward__NDArray(symbol)" = '[]++_backward__NDArray ::+                   forall args . Fullfilled "_backward__NDArray(symbol)" args =>+                     String ->+                       ArgsHMap "_backward__NDArray(symbol)" args -> IO SymbolHandle+_backward__NDArray name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__NDArray"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_MultiBoxTarget(symbol)" =+     '[ '("overlap_threshold", AttrOpt Float),+        '("ignore_label", AttrOpt Float),+        '("negative_mining_ratio", AttrOpt Float),+        '("negative_mining_thresh", AttrOpt Float),+        '("minimum_negative_samples", AttrOpt Int),+        '("variances", AttrOpt [Float]), '("anchor", AttrOpt SymbolHandle),+        '("label", AttrOpt SymbolHandle),+        '("cls_pred", AttrOpt SymbolHandle)]++_contrib_MultiBoxTarget ::+                        forall args . Fullfilled "_contrib_MultiBoxTarget(symbol)" args =>+                          String ->+                            ArgsHMap "_contrib_MultiBoxTarget(symbol)" args -> IO SymbolHandle+_contrib_MultiBoxTarget name args+  = let scalarArgs+          = catMaybes+              [("overlap_threshold",) . showValue <$>+                 (args !? #overlap_threshold :: Maybe Float),+               ("ignore_label",) . showValue <$>+                 (args !? #ignore_label :: Maybe Float),+               ("negative_mining_ratio",) . showValue <$>+                 (args !? #negative_mining_ratio :: Maybe Float),+               ("negative_mining_thresh",) . showValue <$>+                 (args !? #negative_mining_thresh :: Maybe Float),+               ("minimum_negative_samples",) . showValue <$>+                 (args !? #minimum_negative_samples :: Maybe Int),+               ("variances",) . showValue <$>+                 (args !? #variances :: Maybe [Float])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("anchor",) <$> (args !? #anchor :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle),+               ("cls_pred",) <$> (args !? #cls_pred :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxTarget"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_MultiBoxTarget(symbol)" = '[]++_backward__contrib_MultiBoxTarget ::+                                  forall args .+                                    Fullfilled "_backward__contrib_MultiBoxTarget(symbol)" args =>+                                    String ->+                                      ArgsHMap "_backward__contrib_MultiBoxTarget(symbol)" args ->+                                        IO SymbolHandle+_backward__contrib_MultiBoxTarget name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_Proposal(symbol)" =+     '[ '("rpn_pre_nms_top_n", AttrOpt Int),+        '("rpn_post_nms_top_n", AttrOpt Int),+        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),+        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),+        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),+        '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt SymbolHandle),+        '("bbox_pred", AttrOpt SymbolHandle),+        '("im_info", AttrOpt SymbolHandle)]++_contrib_Proposal ::+                  forall args . Fullfilled "_contrib_Proposal(symbol)" args =>+                    String ->+                      ArgsHMap "_contrib_Proposal(symbol)" args -> IO SymbolHandle+_contrib_Proposal name args+  = let scalarArgs+          = catMaybes+              [("rpn_pre_nms_top_n",) . showValue <$>+                 (args !? #rpn_pre_nms_top_n :: Maybe Int),+               ("rpn_post_nms_top_n",) . showValue <$>+                 (args !? #rpn_post_nms_top_n :: Maybe Int),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("rpn_min_size",) . showValue <$>+                 (args !? #rpn_min_size :: Maybe Int),+               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("feature_stride",) . showValue <$>+                 (args !? #feature_stride :: Maybe Int),+               ("output_score",) . showValue <$>+                 (args !? #output_score :: Maybe Bool),+               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle),+               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe SymbolHandle),+               ("im_info",) <$> (args !? #im_info :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_Proposal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward__contrib_Proposal(symbol)" =+     '[]++_backward__contrib_Proposal ::+                            forall args .+                              Fullfilled "_backward__contrib_Proposal(symbol)" args =>+                              String ->+                                ArgsHMap "_backward__contrib_Proposal(symbol)" args ->+                                  IO SymbolHandle+_backward__contrib_Proposal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_Proposal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_count_sketch(symbol)" =+     '[ '("out_dim", AttrReq Int),+        '("processing_batch_size", AttrOpt Int),+        '("data", AttrOpt SymbolHandle), '("h", AttrOpt SymbolHandle),+        '("s", AttrOpt SymbolHandle)]++_contrib_count_sketch ::+                      forall args . Fullfilled "_contrib_count_sketch(symbol)" args =>+                        String ->+                          ArgsHMap "_contrib_count_sketch(symbol)" args -> IO SymbolHandle+_contrib_count_sketch name args+  = let scalarArgs+          = catMaybes+              [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int),+               ("processing_batch_size",) . showValue <$>+                 (args !? #processing_batch_size :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("h",) <$> (args !? #h :: Maybe SymbolHandle),+               ("s",) <$> (args !? #s :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_count_sketch"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_count_sketch(symbol)" = '[]++_backward__contrib_count_sketch ::+                                forall args .+                                  Fullfilled "_backward__contrib_count_sketch(symbol)" args =>+                                  String ->+                                    ArgsHMap "_backward__contrib_count_sketch(symbol)" args ->+                                      IO SymbolHandle+_backward__contrib_count_sketch name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_count_sketch"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_MultiBoxDetection(symbol)" =+     '[ '("clip", AttrOpt Bool), '("threshold", AttrOpt Float),+        '("background_id", AttrOpt Int), '("nms_threshold", AttrOpt Float),+        '("force_suppress", AttrOpt Bool), '("variances", AttrOpt [Float]),+        '("nms_topk", AttrOpt Int), '("cls_prob", AttrOpt SymbolHandle),+        '("loc_pred", AttrOpt SymbolHandle),+        '("anchor", AttrOpt SymbolHandle)]++_contrib_MultiBoxDetection ::+                           forall args .+                             Fullfilled "_contrib_MultiBoxDetection(symbol)" args =>+                             String ->+                               ArgsHMap "_contrib_MultiBoxDetection(symbol)" args ->+                                 IO SymbolHandle+_contrib_MultiBoxDetection name args+  = let scalarArgs+          = catMaybes+              [("clip",) . showValue <$> (args !? #clip :: Maybe Bool),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("background_id",) . showValue <$>+                 (args !? #background_id :: Maybe Int),+               ("nms_threshold",) . showValue <$>+                 (args !? #nms_threshold :: Maybe Float),+               ("force_suppress",) . showValue <$>+                 (args !? #force_suppress :: Maybe Bool),+               ("variances",) . showValue <$>+                 (args !? #variances :: Maybe [Float]),+               ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle),+               ("loc_pred",) <$> (args !? #loc_pred :: Maybe SymbolHandle),+               ("anchor",) <$> (args !? #anchor :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxDetection"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_MultiBoxDetection(symbol)" = '[]++_backward__contrib_MultiBoxDetection ::+                                     forall args .+                                       Fullfilled "_backward__contrib_MultiBoxDetection(symbol)"+                                         args =>+                                       String ->+                                         ArgsHMap "_backward__contrib_MultiBoxDetection(symbol)"+                                           args+                                           -> IO SymbolHandle+_backward__contrib_MultiBoxDetection name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_contrib_DeformablePSROIPooling(symbol)" =+     '[ '("spatial_scale", AttrReq Float), '("output_dim", AttrReq Int),+        '("group_size", AttrReq Int), '("pooled_size", AttrReq Int),+        '("part_size", AttrOpt Int), '("sample_per_part", AttrOpt Int),+        '("trans_std", AttrOpt Float), '("no_trans", AttrOpt Bool),+        '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle),+        '("trans", AttrOpt SymbolHandle)]++_contrib_DeformablePSROIPooling ::+                                forall args .+                                  Fullfilled "_contrib_DeformablePSROIPooling(symbol)" args =>+                                  String ->+                                    ArgsHMap "_contrib_DeformablePSROIPooling(symbol)" args ->+                                      IO SymbolHandle+_contrib_DeformablePSROIPooling name args+  = let scalarArgs+          = catMaybes+              [("spatial_scale",) . showValue <$>+                 (args !? #spatial_scale :: Maybe Float),+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),+               ("group_size",) . showValue <$> (args !? #group_size :: Maybe Int),+               ("pooled_size",) . showValue <$>+                 (args !? #pooled_size :: Maybe Int),+               ("part_size",) . showValue <$> (args !? #part_size :: Maybe Int),+               ("sample_per_part",) . showValue <$>+                 (args !? #sample_per_part :: Maybe Int),+               ("trans_std",) . showValue <$> (args !? #trans_std :: Maybe Float),+               ("no_trans",) . showValue <$> (args !? #no_trans :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle),+               ("trans",) <$> (args !? #trans :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_DeformablePSROIPooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_DeformablePSROIPooling(symbol)" =+     '[]++_backward__contrib_DeformablePSROIPooling ::+                                          forall args .+                                            Fullfilled+                                              "_backward__contrib_DeformablePSROIPooling(symbol)"+                                              args =>+                                            String ->+                                              ArgsHMap+                                                "_backward__contrib_DeformablePSROIPooling(symbol)"+                                                args+                                                -> IO SymbolHandle+_backward__contrib_DeformablePSROIPooling name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_fft(symbol)" =+     '[ '("compute_size", AttrOpt Int), '("data", AttrOpt SymbolHandle)]++_contrib_fft ::+             forall args . Fullfilled "_contrib_fft(symbol)" args =>+               String -> ArgsHMap "_contrib_fft(symbol)" args -> IO SymbolHandle+_contrib_fft name args+  = let scalarArgs+          = catMaybes+              [("compute_size",) . showValue <$>+                 (args !? #compute_size :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_fft"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward__contrib_fft(symbol)" = '[]++_backward__contrib_fft ::+                       forall args . Fullfilled "_backward__contrib_fft(symbol)" args =>+                         String ->+                           ArgsHMap "_backward__contrib_fft(symbol)" args -> IO SymbolHandle+_backward__contrib_fft name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_fft"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_MultiBoxPrior(symbol)" =+     '[ '("sizes", AttrOpt [Float]), '("ratios", AttrOpt [Float]),+        '("clip", AttrOpt Bool), '("steps", AttrOpt [Float]),+        '("offsets", AttrOpt [Float]), '("data", AttrOpt SymbolHandle)]++_contrib_MultiBoxPrior ::+                       forall args . Fullfilled "_contrib_MultiBoxPrior(symbol)" args =>+                         String ->+                           ArgsHMap "_contrib_MultiBoxPrior(symbol)" args -> IO SymbolHandle+_contrib_MultiBoxPrior name args+  = let scalarArgs+          = catMaybes+              [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("clip",) . showValue <$> (args !? #clip :: Maybe Bool),+               ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]),+               ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiBoxPrior"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_MultiBoxPrior(symbol)" = '[]++_backward__contrib_MultiBoxPrior ::+                                 forall args .+                                   Fullfilled "_backward__contrib_MultiBoxPrior(symbol)" args =>+                                   String ->+                                     ArgsHMap "_backward__contrib_MultiBoxPrior(symbol)" args ->+                                       IO SymbolHandle+_backward__contrib_MultiBoxPrior name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_MultiProposal(symbol)" =+     '[ '("rpn_pre_nms_top_n", AttrOpt Int),+        '("rpn_post_nms_top_n", AttrOpt Int),+        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),+        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),+        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),+        '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt SymbolHandle),+        '("bbox_pred", AttrOpt SymbolHandle),+        '("im_info", AttrOpt SymbolHandle)]++_contrib_MultiProposal ::+                       forall args . Fullfilled "_contrib_MultiProposal(symbol)" args =>+                         String ->+                           ArgsHMap "_contrib_MultiProposal(symbol)" args -> IO SymbolHandle+_contrib_MultiProposal name args+  = let scalarArgs+          = catMaybes+              [("rpn_pre_nms_top_n",) . showValue <$>+                 (args !? #rpn_pre_nms_top_n :: Maybe Int),+               ("rpn_post_nms_top_n",) . showValue <$>+                 (args !? #rpn_post_nms_top_n :: Maybe Int),+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),+               ("rpn_min_size",) . showValue <$>+                 (args !? #rpn_min_size :: Maybe Int),+               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),+               ("feature_stride",) . showValue <$>+                 (args !? #feature_stride :: Maybe Int),+               ("output_score",) . showValue <$>+                 (args !? #output_score :: Maybe Bool),+               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle),+               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe SymbolHandle),+               ("im_info",) <$> (args !? #im_info :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_MultiProposal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_MultiProposal(symbol)" = '[]++_backward__contrib_MultiProposal ::+                                 forall args .+                                   Fullfilled "_backward__contrib_MultiProposal(symbol)" args =>+                                   String ->+                                     ArgsHMap "_backward__contrib_MultiProposal(symbol)" args ->+                                       IO SymbolHandle+_backward__contrib_MultiProposal name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_MultiProposal"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_PSROIPooling(symbol)" =+     '[ '("spatial_scale", AttrReq Float), '("output_dim", AttrReq Int),+        '("pooled_size", AttrReq Int), '("group_size", AttrOpt Int),+        '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle)]++_contrib_PSROIPooling ::+                      forall args . Fullfilled "_contrib_PSROIPooling(symbol)" args =>+                        String ->+                          ArgsHMap "_contrib_PSROIPooling(symbol)" args -> IO SymbolHandle+_contrib_PSROIPooling name args+  = let scalarArgs+          = catMaybes+              [("spatial_scale",) . showValue <$>+                 (args !? #spatial_scale :: Maybe Float),+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),+               ("pooled_size",) . showValue <$>+                 (args !? #pooled_size :: Maybe Int),+               ("group_size",) . showValue <$> (args !? #group_size :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_PSROIPooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_PSROIPooling(symbol)" = '[]++_backward__contrib_PSROIPooling ::+                                forall args .+                                  Fullfilled "_backward__contrib_PSROIPooling(symbol)" args =>+                                  String ->+                                    ArgsHMap "_backward__contrib_PSROIPooling(symbol)" args ->+                                      IO SymbolHandle+_backward__contrib_PSROIPooling name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_PSROIPooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_contrib_DeformableConvolution(symbol)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("num_deformable_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("layout", AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NCW"]))),+        '("data", AttrOpt SymbolHandle), '("offset", AttrOpt SymbolHandle),+        '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle)]++_contrib_DeformableConvolution ::+                               forall args .+                                 Fullfilled "_contrib_DeformableConvolution(symbol)" args =>+                                 String ->+                                   ArgsHMap "_contrib_DeformableConvolution(symbol)" args ->+                                     IO SymbolHandle+_contrib_DeformableConvolution name args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("num_deformable_group",) . showValue <$>+                 (args !? #num_deformable_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("offset",) <$> (args !? #offset :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_DeformableConvolution"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_DeformableConvolution(symbol)" =+     '[]++_backward__contrib_DeformableConvolution ::+                                         forall args .+                                           Fullfilled+                                             "_backward__contrib_DeformableConvolution(symbol)"+                                             args =>+                                           String ->+                                             ArgsHMap+                                               "_backward__contrib_DeformableConvolution(symbol)"+                                               args+                                               -> IO SymbolHandle+_backward__contrib_DeformableConvolution name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_contrib_ifft(symbol)" =+     '[ '("compute_size", AttrOpt Int), '("data", AttrOpt SymbolHandle)]++_contrib_ifft ::+              forall args . Fullfilled "_contrib_ifft(symbol)" args =>+                String -> ArgsHMap "_contrib_ifft(symbol)" args -> IO SymbolHandle+_contrib_ifft name args+  = let scalarArgs+          = catMaybes+              [("compute_size",) . showValue <$>+                 (args !? #compute_size :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_contrib_ifft"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward__contrib_ifft(symbol)" = '[]++_backward__contrib_ifft ::+                        forall args . Fullfilled "_backward__contrib_ifft(symbol)" args =>+                          String ->+                            ArgsHMap "_backward__contrib_ifft(symbol)" args -> IO SymbolHandle+_backward__contrib_ifft name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_ifft"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward__contrib_SyncBatchNorm(symbol)" = '[]++_backward__contrib_SyncBatchNorm ::+                                 forall args .+                                   Fullfilled "_backward__contrib_SyncBatchNorm(symbol)" args =>+                                   String ->+                                     ArgsHMap "_backward__contrib_SyncBatchNorm(symbol)" args ->+                                       IO SymbolHandle+_backward__contrib_SyncBatchNorm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__contrib_SyncBatchNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_InstanceNorm(symbol)" =+     '[ '("eps", AttrOpt Float), '("data", AttrOpt SymbolHandle),+        '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle)]++_InstanceNorm ::+              forall args . Fullfilled "_InstanceNorm(symbol)" args =>+                String -> ArgsHMap "_InstanceNorm(symbol)" args -> IO SymbolHandle+_InstanceNorm name args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),+               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "InstanceNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_InstanceNorm(symbol)" = '[]++_backward_InstanceNorm ::+                       forall args . Fullfilled "_backward_InstanceNorm(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_InstanceNorm(symbol)" args -> IO SymbolHandle+_backward_InstanceNorm name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_InstanceNorm"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SVMOutput(symbol)" =+     '[ '("margin", AttrOpt Float),+        '("regularization_coefficient", AttrOpt Float),+        '("use_linear", AttrOpt Bool), '("data", AttrOpt SymbolHandle),+        '("label", AttrOpt SymbolHandle)]++_SVMOutput ::+           forall args . Fullfilled "_SVMOutput(symbol)" args =>+             String -> ArgsHMap "_SVMOutput(symbol)" args -> IO SymbolHandle+_SVMOutput name args+  = let scalarArgs+          = catMaybes+              [("margin",) . showValue <$> (args !? #margin :: Maybe Float),+               ("regularization_coefficient",) . showValue <$>+                 (args !? #regularization_coefficient :: Maybe Float),+               ("use_linear",) . showValue <$>+                 (args !? #use_linear :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SVMOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SVMOutput(symbol)" = '[]++_backward_SVMOutput ::+                    forall args . Fullfilled "_backward_SVMOutput(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_SVMOutput(symbol)" args -> IO SymbolHandle+_backward_SVMOutput name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SVMOutput"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_GridGenerator(symbol)" =+     '[ '("transform_type", AttrReq (EnumType '["affine", "warp"])),+        '("target_shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]++_GridGenerator ::+               forall args . Fullfilled "_GridGenerator(symbol)" args =>+                 String -> ArgsHMap "_GridGenerator(symbol)" args -> IO SymbolHandle+_GridGenerator name args+  = let scalarArgs+          = catMaybes+              [("transform_type",) . showValue <$>+                 (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])),+               ("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "GridGenerator"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_GridGenerator(symbol)" = '[]++_backward_GridGenerator ::+                        forall args . Fullfilled "_backward_GridGenerator(symbol)" args =>+                          String ->+                            ArgsHMap "_backward_GridGenerator(symbol)" args -> IO SymbolHandle+_backward_GridGenerator name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_GridGenerator"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Convolution_v1(symbol)" =+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),+        '("cudnn_tune",+          AttrOpt+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+        '("cudnn_off", AttrOpt Bool),+        '("layout",+          AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"]))),+        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),+        '("bias", AttrOpt SymbolHandle)]++_Convolution_v1 ::+                forall args . Fullfilled "_Convolution_v1(symbol)" args =>+                  String ->+                    ArgsHMap "_Convolution_v1(symbol)" args -> IO SymbolHandle+_Convolution_v1 name args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),+               ("cudnn_tune",) . showValue <$>+                 (args !? #cudnn_tune ::+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),+               ("layout",) . showValue <$>+                 (args !? #layout ::+                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),+               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Convolution_v1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Convolution_v1(symbol)" =+     '[]++_backward_Convolution_v1 ::+                         forall args . Fullfilled "_backward_Convolution_v1(symbol)" args =>+                           String ->+                             ArgsHMap "_backward_Convolution_v1(symbol)" args -> IO SymbolHandle+_backward_Convolution_v1 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Convolution_v1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SequenceReverse(symbol)" =+     '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int),+        '("data", AttrOpt SymbolHandle),+        '("sequence_length", AttrOpt SymbolHandle)]++_SequenceReverse ::+                 forall args . Fullfilled "_SequenceReverse(symbol)" args =>+                   String ->+                     ArgsHMap "_SequenceReverse(symbol)" args -> IO SymbolHandle+_SequenceReverse name args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceReverse"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SequenceReverse(symbol)" =+     '[]++_backward_SequenceReverse ::+                          forall args .+                            Fullfilled "_backward_SequenceReverse(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_SequenceReverse(symbol)" args ->+                                IO SymbolHandle+_backward_SequenceReverse name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceReverse"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_BilinearSampler(symbol)" =+     '[ '("cudnn_off", AttrOpt (Maybe Bool)),+        '("data", AttrOpt SymbolHandle), '("grid", AttrOpt SymbolHandle)]++_BilinearSampler ::+                 forall args . Fullfilled "_BilinearSampler(symbol)" args =>+                   String ->+                     ArgsHMap "_BilinearSampler(symbol)" args -> IO SymbolHandle+_BilinearSampler name args+  = let scalarArgs+          = catMaybes+              [("cudnn_off",) . showValue <$>+                 (args !? #cudnn_off :: Maybe (Maybe Bool))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("grid",) <$> (args !? #grid :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "BilinearSampler"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_BilinearSampler(symbol)" =+     '[]++_backward_BilinearSampler ::+                          forall args .+                            Fullfilled "_backward_BilinearSampler(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_BilinearSampler(symbol)" args ->+                                IO SymbolHandle+_backward_BilinearSampler name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BilinearSampler"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_LeakyReLU(symbol)" = '[]++_backward_LeakyReLU ::+                    forall args . Fullfilled "_backward_LeakyReLU(symbol)" args =>+                      String ->+                        ArgsHMap "_backward_LeakyReLU(symbol)" args -> IO SymbolHandle+_backward_LeakyReLU name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_LeakyReLU"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Crop(symbol)" =+     '[ '("num_args", AttrReq Int), '("offset", AttrOpt [Int]),+        '("h_w", AttrOpt [Int]), '("center_crop", AttrOpt Bool),+        '("data", AttrOpt [SymbolHandle])]++_Crop ::+      forall args . Fullfilled "_Crop(symbol)" args =>+        String -> ArgsHMap "_Crop(symbol)" args -> IO SymbolHandle+_Crop name args+  = let scalarArgs+          = catMaybes+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),+               ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]),+               ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]),+               ("center_crop",) . showValue <$>+                 (args !? #center_crop :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])+      in+      do op <- nnGetOpHandle "Crop"+         sym <- if hasKey args #num_args then+                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals+                  else+                  mxSymbolCreateAtomicSymbol (fromOpHandle op)+                    ("num_args" : scalarkeys)+                    (showValue (length array) : scalarvals)+         mxSymbolCompose sym name Nothing array+         return sym++type instance ParameterList "_backward_Crop(symbol)" = '[]++_backward_Crop ::+               forall args . Fullfilled "_backward_Crop(symbol)" args =>+                 String -> ArgsHMap "_backward_Crop(symbol)" args -> IO SymbolHandle+_backward_Crop name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Crop"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_ROIPooling(symbol)" =+     '[ '("pooled_size", AttrReq [Int]),+        '("spatial_scale", AttrReq Float), '("data", AttrOpt SymbolHandle),+        '("rois", AttrOpt SymbolHandle)]++_ROIPooling ::+            forall args . Fullfilled "_ROIPooling(symbol)" args =>+              String -> ArgsHMap "_ROIPooling(symbol)" args -> IO SymbolHandle+_ROIPooling name args+  = let scalarArgs+          = catMaybes+              [("pooled_size",) . showValue <$>+                 (args !? #pooled_size :: Maybe [Int]),+               ("spatial_scale",) . showValue <$>+                 (args !? #spatial_scale :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "ROIPooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_ROIPooling(symbol)" = '[]++_backward_ROIPooling ::+                     forall args . Fullfilled "_backward_ROIPooling(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_ROIPooling(symbol)" args -> IO SymbolHandle+_backward_ROIPooling name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_ROIPooling"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SequenceLast(symbol)" =+     '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int),+        '("data", AttrOpt SymbolHandle),+        '("sequence_length", AttrOpt SymbolHandle)]++_SequenceLast ::+              forall args . Fullfilled "_SequenceLast(symbol)" args =>+                String -> ArgsHMap "_SequenceLast(symbol)" args -> IO SymbolHandle+_SequenceLast name args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceLast"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SequenceLast(symbol)" = '[]++_backward_SequenceLast ::+                       forall args . Fullfilled "_backward_SequenceLast(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_SequenceLast(symbol)" args -> IO SymbolHandle+_backward_SequenceLast name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceLast"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_CrossDeviceCopy(symbol)" = '[]++_CrossDeviceCopy ::+                 forall args . Fullfilled "_CrossDeviceCopy(symbol)" args =>+                   String ->+                     ArgsHMap "_CrossDeviceCopy(symbol)" args -> IO SymbolHandle+_CrossDeviceCopy name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_CrossDeviceCopy"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward__CrossDeviceCopy(symbol)" =+     '[]++_backward__CrossDeviceCopy ::+                           forall args .+                             Fullfilled "_backward__CrossDeviceCopy(symbol)" args =>+                             String ->+                               ArgsHMap "_backward__CrossDeviceCopy(symbol)" args ->+                                 IO SymbolHandle+_backward__CrossDeviceCopy name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward__CrossDeviceCopy"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SpatialTransformer(symbol)" =+     '[ '("target_shape", AttrOpt [Int]),+        '("transform_type", AttrReq (EnumType '["affine"])),+        '("sampler_type", AttrReq (EnumType '["bilinear"])),+        '("cudnn_off", AttrOpt (Maybe Bool)),+        '("data", AttrOpt SymbolHandle), '("loc", AttrOpt SymbolHandle)]++_SpatialTransformer ::+                    forall args . Fullfilled "_SpatialTransformer(symbol)" args =>+                      String ->+                        ArgsHMap "_SpatialTransformer(symbol)" args -> IO SymbolHandle+_SpatialTransformer name args+  = let scalarArgs+          = catMaybes+              [("target_shape",) . showValue <$>+                 (args !? #target_shape :: Maybe [Int]),+               ("transform_type",) . showValue <$>+                 (args !? #transform_type :: Maybe (EnumType '["affine"])),+               ("sampler_type",) . showValue <$>+                 (args !? #sampler_type :: Maybe (EnumType '["bilinear"])),+               ("cudnn_off",) . showValue <$>+                 (args !? #cudnn_off :: Maybe (Maybe Bool))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("loc",) <$> (args !? #loc :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SpatialTransformer"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SpatialTransformer(symbol)"+     = '[]++_backward_SpatialTransformer ::+                             forall args .+                               Fullfilled "_backward_SpatialTransformer(symbol)" args =>+                               String ->+                                 ArgsHMap "_backward_SpatialTransformer(symbol)" args ->+                                   IO SymbolHandle+_backward_SpatialTransformer name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SpatialTransformer"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SwapAxis(symbol)" = '[]++_backward_SwapAxis ::+                   forall args . Fullfilled "_backward_SwapAxis(symbol)" args =>+                     String ->+                       ArgsHMap "_backward_SwapAxis(symbol)" args -> IO SymbolHandle+_backward_SwapAxis name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SwapAxis"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_L2Normalization(symbol)" =+     '[ '("eps", AttrOpt Float),+        '("mode", AttrOpt (EnumType '["channel", "instance", "spatial"])),+        '("data", AttrOpt SymbolHandle)]++_L2Normalization ::+                 forall args . Fullfilled "_L2Normalization(symbol)" args =>+                   String ->+                     ArgsHMap "_L2Normalization(symbol)" args -> IO SymbolHandle+_L2Normalization name args+  = let scalarArgs+          = catMaybes+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),+               ("mode",) . showValue <$>+                 (args !? #mode ::+                    Maybe (EnumType '["channel", "instance", "spatial"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "L2Normalization"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_L2Normalization(symbol)" =+     '[]++_backward_L2Normalization ::+                          forall args .+                            Fullfilled "_backward_L2Normalization(symbol)" args =>+                            String ->+                              ArgsHMap "_backward_L2Normalization(symbol)" args ->+                                IO SymbolHandle+_backward_L2Normalization name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_L2Normalization"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Correlation(symbol)" =+     '[ '("kernel_size", AttrOpt Int),+        '("max_displacement", AttrOpt Int), '("stride1", AttrOpt Int),+        '("stride2", AttrOpt Int), '("pad_size", AttrOpt Int),+        '("is_multiply", AttrOpt Bool), '("data1", AttrOpt SymbolHandle),+        '("data2", AttrOpt SymbolHandle)]++_Correlation ::+             forall args . Fullfilled "_Correlation(symbol)" args =>+               String -> ArgsHMap "_Correlation(symbol)" args -> IO SymbolHandle+_Correlation name args+  = let scalarArgs+          = catMaybes+              [("kernel_size",) . showValue <$>+                 (args !? #kernel_size :: Maybe Int),+               ("max_displacement",) . showValue <$>+                 (args !? #max_displacement :: Maybe Int),+               ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int),+               ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int),+               ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int),+               ("is_multiply",) . showValue <$>+                 (args !? #is_multiply :: Maybe Bool)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data1",) <$> (args !? #data1 :: Maybe SymbolHandle),+               ("data2",) <$> (args !? #data2 :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Correlation"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Correlation(symbol)" = '[]++_backward_Correlation ::+                      forall args . Fullfilled "_backward_Correlation(symbol)" args =>+                        String ->+                          ArgsHMap "_backward_Correlation(symbol)" args -> IO SymbolHandle+_backward_Correlation name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Correlation"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance+     ParameterList "_backward_IdentityAttachKLSparseReg(symbol)" = '[]++_backward_IdentityAttachKLSparseReg ::+                                    forall args .+                                      Fullfilled "_backward_IdentityAttachKLSparseReg(symbol)"+                                        args =>+                                      String ->+                                        ArgsHMap "_backward_IdentityAttachKLSparseReg(symbol)" args+                                          -> IO SymbolHandle+_backward_IdentityAttachKLSparseReg name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_MakeLoss(symbol)" =+     '[ '("grad_scale", AttrOpt Float),+        '("valid_thresh", AttrOpt Float),+        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),+        '("data", AttrOpt SymbolHandle)]++_MakeLoss ::+          forall args . Fullfilled "_MakeLoss(symbol)" args =>+            String -> ArgsHMap "_MakeLoss(symbol)" args -> IO SymbolHandle+_MakeLoss name args+  = let scalarArgs+          = catMaybes+              [("grad_scale",) . showValue <$>+                 (args !? #grad_scale :: Maybe Float),+               ("valid_thresh",) . showValue <$>+                 (args !? #valid_thresh :: Maybe Float),+               ("normalization",) . showValue <$>+                 (args !? #normalization ::+                    Maybe (EnumType '["batch", "null", "valid"]))]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "MakeLoss"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_MakeLoss(symbol)" = '[]++_backward_MakeLoss ::+                   forall args . Fullfilled "_backward_MakeLoss(symbol)" args =>+                     String ->+                       ArgsHMap "_backward_MakeLoss(symbol)" args -> IO SymbolHandle+_backward_MakeLoss name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_MakeLoss"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SliceChannel(symbol)" = '[]++_backward_SliceChannel ::+                       forall args . Fullfilled "_backward_SliceChannel(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_SliceChannel(symbol)" args -> IO SymbolHandle+_backward_SliceChannel name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SliceChannel"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_Pooling_v1(symbol)" =+     '[ '("kernel", AttrOpt [Int]),+        '("pool_type", AttrOpt (EnumType '["avg", "max", "sum"])),+        '("global_pool", AttrOpt Bool),+        '("pooling_convention", AttrOpt (EnumType '["full", "valid"])),+        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),+        '("data", AttrOpt SymbolHandle)]++_Pooling_v1 ::+            forall args . Fullfilled "_Pooling_v1(symbol)" args =>+              String -> ArgsHMap "_Pooling_v1(symbol)" args -> IO SymbolHandle+_Pooling_v1 name args+  = let scalarArgs+          = catMaybes+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),+               ("pool_type",) . showValue <$>+                 (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])),+               ("global_pool",) . showValue <$>+                 (args !? #global_pool :: Maybe Bool),+               ("pooling_convention",) . showValue <$>+                 (args !? #pooling_convention ::+                    Maybe (EnumType '["full", "valid"])),+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "Pooling_v1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Pooling_v1(symbol)" = '[]++_backward_Pooling_v1 ::+                     forall args . Fullfilled "_backward_Pooling_v1(symbol)" args =>+                       String ->+                         ArgsHMap "_backward_Pooling_v1(symbol)" args -> IO SymbolHandle+_backward_Pooling_v1 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pooling_v1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_Pad(symbol)" = '[]++_backward_Pad ::+              forall args . Fullfilled "_backward_Pad(symbol)" args =>+                String -> ArgsHMap "_backward_Pad(symbol)" args -> IO SymbolHandle+_backward_Pad name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_Pad"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_BatchNorm_v1(symbol)" = '[]++_backward_BatchNorm_v1 ::+                       forall args . Fullfilled "_backward_BatchNorm_v1(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_BatchNorm_v1(symbol)" args -> IO SymbolHandle+_backward_BatchNorm_v1 name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_BatchNorm_v1"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_SequenceMask(symbol)" =+     '[ '("use_sequence_length", AttrOpt Bool),+        '("value", AttrOpt Float), '("axis", AttrOpt Int),+        '("data", AttrOpt SymbolHandle),+        '("sequence_length", AttrOpt SymbolHandle)]++_SequenceMask ::+              forall args . Fullfilled "_SequenceMask(symbol)" args =>+                String -> ArgsHMap "_SequenceMask(symbol)" args -> IO SymbolHandle+_SequenceMask name args+  = let scalarArgs+          = catMaybes+              [("use_sequence_length",) . showValue <$>+                 (args !? #use_sequence_length :: Maybe Bool),+               ("value",) . showValue <$> (args !? #value :: Maybe Float),+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes+              [("data",) <$> (args !? #data :: Maybe SymbolHandle),+               ("sequence_length",) <$>+                 (args !? #sequence_length :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "SequenceMask"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_backward_SequenceMask(symbol)" = '[]++_backward_SequenceMask ::+                       forall args . Fullfilled "_backward_SequenceMask(symbol)" args =>+                         String ->+                           ArgsHMap "_backward_SequenceMask(symbol)" args -> IO SymbolHandle+_backward_SequenceMask name args+  = let scalarArgs = catMaybes []+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_backward_SequenceMask"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_set_value(symbol)" =+     '[ '("src", AttrOpt Float)]++_set_value ::+           forall args . Fullfilled "_set_value(symbol)" args =>+             String -> ArgsHMap "_set_value(symbol)" args -> IO SymbolHandle+_set_value name args+  = let scalarArgs+          = catMaybes+              [("src",) . showValue <$> (args !? #src :: Maybe Float)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs = catMaybes []+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_set_value"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym++type instance ParameterList "_imdecode(symbol)" =+     '[ '("index", AttrOpt Int), '("x0", AttrOpt Int),+        '("y0", AttrOpt Int), '("x1", AttrOpt Int), '("y1", AttrOpt Int),+        '("c", AttrOpt Int), '("size", AttrOpt Int),+        '("mean", AttrOpt SymbolHandle)]++_imdecode ::+          forall args . Fullfilled "_imdecode(symbol)" args =>+            String -> ArgsHMap "_imdecode(symbol)" args -> IO SymbolHandle+_imdecode name args+  = let scalarArgs+          = catMaybes+              [("index",) . showValue <$> (args !? #index :: Maybe Int),+               ("x0",) . showValue <$> (args !? #x0 :: Maybe Int),+               ("y0",) . showValue <$> (args !? #y0 :: Maybe Int),+               ("x1",) . showValue <$> (args !? #x1 :: Maybe Int),+               ("y1",) . showValue <$> (args !? #y1 :: Maybe Int),+               ("c",) . showValue <$> (args !? #c :: Maybe Int),+               ("size",) . showValue <$> (args !? #size :: Maybe Int)]+        (scalarkeys, scalarvals) = unzip scalarArgs+        tensorArgs+          = catMaybes [("mean",) <$> (args !? #mean :: Maybe SymbolHandle)]+        (tensorkeys, tensorvals) = unzip tensorArgs+      in+      do op <- nnGetOpHandle "_imdecode"+         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys+                  scalarvals+         mxSymbolCompose sym name (Just tensorkeys) tensorvals+         return sym