{- This file was auto-generated from tensorflow/core/protobuf/config.proto by the proto-lens-protoc program. -}
{-# LANGUAGE ScopedTypeVariables, DataKinds, TypeFamilies,
  UndecidableInstances, MultiParamTypeClasses, FlexibleContexts,
  FlexibleInstances, PatternSynonyms, MagicHash, NoImplicitPrelude
  #-}
{-# OPTIONS_GHC -fno-warn-unused-imports#-}
module Proto.Tensorflow.Core.Protobuf.Config where
import qualified Data.ProtoLens.Reexport.Prelude as Prelude
import qualified Data.ProtoLens.Reexport.Data.Int as Data.Int
import qualified Data.ProtoLens.Reexport.Data.Word as Data.Word
import qualified Data.ProtoLens.Reexport.Data.ProtoLens
       as Data.ProtoLens
import qualified
       Data.ProtoLens.Reexport.Data.ProtoLens.Message.Enum
       as Data.ProtoLens.Message.Enum
import qualified Data.ProtoLens.Reexport.Lens.Family2
       as Lens.Family2
import qualified Data.ProtoLens.Reexport.Lens.Family2.Unchecked
       as Lens.Family2.Unchecked
import qualified Data.ProtoLens.Reexport.Data.Default.Class
       as Data.Default.Class
import qualified Data.ProtoLens.Reexport.Data.Text as Data.Text
import qualified Data.ProtoLens.Reexport.Data.Map as Data.Map
import qualified Data.ProtoLens.Reexport.Data.ByteString
       as Data.ByteString
import qualified Data.ProtoLens.Reexport.Lens.Labels as Lens.Labels
import qualified Proto.Tensorflow.Core.Framework.CostGraph
import qualified Proto.Tensorflow.Core.Framework.Graph
import qualified Proto.Tensorflow.Core.Framework.StepStats
import qualified Proto.Tensorflow.Core.Protobuf.Cluster
import qualified Proto.Tensorflow.Core.Protobuf.Debug
import qualified Proto.Tensorflow.Core.Protobuf.RewriterConfig

data CallableOptions = CallableOptions{_CallableOptions'feed ::
                                       ![Data.Text.Text],
                                       _CallableOptions'fetch :: ![Data.Text.Text],
                                       _CallableOptions'target :: ![Data.Text.Text],
                                       _CallableOptions'runOptions :: !(Prelude.Maybe RunOptions),
                                       _CallableOptions'tensorConnection :: ![TensorConnection]}
                     deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance (a ~ [Data.Text.Text], b ~ [Data.Text.Text],
          Prelude.Functor f) =>
         Lens.Labels.HasLens "feed" f CallableOptions CallableOptions a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _CallableOptions'feed
                 (\ x__ y__ -> x__{_CallableOptions'feed = y__}))
              Prelude.id

instance (a ~ [Data.Text.Text], b ~ [Data.Text.Text],
          Prelude.Functor f) =>
         Lens.Labels.HasLens "fetch" f CallableOptions CallableOptions a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _CallableOptions'fetch
                 (\ x__ y__ -> x__{_CallableOptions'fetch = y__}))
              Prelude.id

instance (a ~ [Data.Text.Text], b ~ [Data.Text.Text],
          Prelude.Functor f) =>
         Lens.Labels.HasLens "target" f CallableOptions CallableOptions a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _CallableOptions'target
                 (\ x__ y__ -> x__{_CallableOptions'target = y__}))
              Prelude.id

instance (a ~ RunOptions, b ~ RunOptions, Prelude.Functor f) =>
         Lens.Labels.HasLens "runOptions" f CallableOptions CallableOptions
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _CallableOptions'runOptions
                 (\ x__ y__ -> x__{_CallableOptions'runOptions = y__}))
              (Data.ProtoLens.maybeLens Data.Default.Class.def)

instance (a ~ Prelude.Maybe RunOptions,
          b ~ Prelude.Maybe RunOptions, Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'runOptions" f CallableOptions
           CallableOptions
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _CallableOptions'runOptions
                 (\ x__ y__ -> x__{_CallableOptions'runOptions = y__}))
              Prelude.id

instance (a ~ [TensorConnection], b ~ [TensorConnection],
          Prelude.Functor f) =>
         Lens.Labels.HasLens "tensorConnection" f CallableOptions
           CallableOptions
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _CallableOptions'tensorConnection
                 (\ x__ y__ -> x__{_CallableOptions'tensorConnection = y__}))
              Prelude.id

instance Data.Default.Class.Default CallableOptions where
        def
          = CallableOptions{_CallableOptions'feed = [],
                            _CallableOptions'fetch = [], _CallableOptions'target = [],
                            _CallableOptions'runOptions = Prelude.Nothing,
                            _CallableOptions'tensorConnection = []}

instance Data.ProtoLens.Message CallableOptions where
        descriptor
          = let feed__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "feed"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked feed)
                      :: Data.ProtoLens.FieldDescriptor CallableOptions
                fetch__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "fetch"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked fetch)
                      :: Data.ProtoLens.FieldDescriptor CallableOptions
                target__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "target"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked target)
                      :: Data.ProtoLens.FieldDescriptor CallableOptions
                runOptions__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "run_options"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor RunOptions)
                      (Data.ProtoLens.OptionalField maybe'runOptions)
                      :: Data.ProtoLens.FieldDescriptor CallableOptions
                tensorConnection__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "tensor_connection"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor TensorConnection)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked
                         tensorConnection)
                      :: Data.ProtoLens.FieldDescriptor CallableOptions
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.CallableOptions")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, feed__field_descriptor),
                    (Data.ProtoLens.Tag 2, fetch__field_descriptor),
                    (Data.ProtoLens.Tag 3, target__field_descriptor),
                    (Data.ProtoLens.Tag 4, runOptions__field_descriptor),
                    (Data.ProtoLens.Tag 5, tensorConnection__field_descriptor)])
                (Data.Map.fromList
                   [("feed", feed__field_descriptor),
                    ("fetch", fetch__field_descriptor),
                    ("target", target__field_descriptor),
                    ("run_options", runOptions__field_descriptor),
                    ("tensor_connection", tensorConnection__field_descriptor)])

data ConfigProto = ConfigProto{_ConfigProto'deviceCount ::
                               !(Data.Map.Map Data.Text.Text Data.Int.Int32),
                               _ConfigProto'intraOpParallelismThreads :: !Data.Int.Int32,
                               _ConfigProto'interOpParallelismThreads :: !Data.Int.Int32,
                               _ConfigProto'usePerSessionThreads :: !Prelude.Bool,
                               _ConfigProto'sessionInterOpThreadPool :: ![ThreadPoolOptionProto],
                               _ConfigProto'placementPeriod :: !Data.Int.Int32,
                               _ConfigProto'deviceFilters :: ![Data.Text.Text],
                               _ConfigProto'gpuOptions :: !(Prelude.Maybe GPUOptions),
                               _ConfigProto'allowSoftPlacement :: !Prelude.Bool,
                               _ConfigProto'logDevicePlacement :: !Prelude.Bool,
                               _ConfigProto'graphOptions :: !(Prelude.Maybe GraphOptions),
                               _ConfigProto'operationTimeoutInMs :: !Data.Int.Int64,
                               _ConfigProto'rpcOptions :: !(Prelude.Maybe RPCOptions),
                               _ConfigProto'clusterDef ::
                               !(Prelude.Maybe Proto.Tensorflow.Core.Protobuf.Cluster.ClusterDef),
                               _ConfigProto'isolateSessionState :: !Prelude.Bool,
                               _ConfigProto'experimental ::
                               !(Prelude.Maybe ConfigProto'Experimental)}
                 deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance (a ~ Data.Map.Map Data.Text.Text Data.Int.Int32,
          b ~ Data.Map.Map Data.Text.Text Data.Int.Int32,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "deviceCount" f ConfigProto ConfigProto a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _ConfigProto'deviceCount
                 (\ x__ y__ -> x__{_ConfigProto'deviceCount = y__}))
              Prelude.id

instance (a ~ Data.Int.Int32, b ~ Data.Int.Int32,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "intraOpParallelismThreads" f ConfigProto
           ConfigProto
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _ConfigProto'intraOpParallelismThreads
                 (\ x__ y__ -> x__{_ConfigProto'intraOpParallelismThreads = y__}))
              Prelude.id

instance (a ~ Data.Int.Int32, b ~ Data.Int.Int32,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "interOpParallelismThreads" f ConfigProto
           ConfigProto
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _ConfigProto'interOpParallelismThreads
                 (\ x__ y__ -> x__{_ConfigProto'interOpParallelismThreads = y__}))
              Prelude.id

instance (a ~ Prelude.Bool, b ~ Prelude.Bool, Prelude.Functor f) =>
         Lens.Labels.HasLens "usePerSessionThreads" f ConfigProto
           ConfigProto
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _ConfigProto'usePerSessionThreads
                 (\ x__ y__ -> x__{_ConfigProto'usePerSessionThreads = y__}))
              Prelude.id

instance (a ~ [ThreadPoolOptionProto], b ~ [ThreadPoolOptionProto],
          Prelude.Functor f) =>
         Lens.Labels.HasLens "sessionInterOpThreadPool" f ConfigProto
           ConfigProto
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _ConfigProto'sessionInterOpThreadPool
                 (\ x__ y__ -> x__{_ConfigProto'sessionInterOpThreadPool = y__}))
              Prelude.id

instance (a ~ Data.Int.Int32, b ~ Data.Int.Int32,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "placementPeriod" f ConfigProto ConfigProto a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _ConfigProto'placementPeriod
                 (\ x__ y__ -> x__{_ConfigProto'placementPeriod = y__}))
              Prelude.id

instance (a ~ [Data.Text.Text], b ~ [Data.Text.Text],
          Prelude.Functor f) =>
         Lens.Labels.HasLens "deviceFilters" f ConfigProto ConfigProto a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _ConfigProto'deviceFilters
                 (\ x__ y__ -> x__{_ConfigProto'deviceFilters = y__}))
              Prelude.id

instance (a ~ GPUOptions, b ~ GPUOptions, Prelude.Functor f) =>
         Lens.Labels.HasLens "gpuOptions" f ConfigProto ConfigProto a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _ConfigProto'gpuOptions
                 (\ x__ y__ -> x__{_ConfigProto'gpuOptions = y__}))
              (Data.ProtoLens.maybeLens Data.Default.Class.def)

instance (a ~ Prelude.Maybe GPUOptions,
          b ~ Prelude.Maybe GPUOptions, Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'gpuOptions" f ConfigProto ConfigProto a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _ConfigProto'gpuOptions
                 (\ x__ y__ -> x__{_ConfigProto'gpuOptions = y__}))
              Prelude.id

instance (a ~ Prelude.Bool, b ~ Prelude.Bool, Prelude.Functor f) =>
         Lens.Labels.HasLens "allowSoftPlacement" f ConfigProto ConfigProto
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _ConfigProto'allowSoftPlacement
                 (\ x__ y__ -> x__{_ConfigProto'allowSoftPlacement = y__}))
              Prelude.id

instance (a ~ Prelude.Bool, b ~ Prelude.Bool, Prelude.Functor f) =>
         Lens.Labels.HasLens "logDevicePlacement" f ConfigProto ConfigProto
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _ConfigProto'logDevicePlacement
                 (\ x__ y__ -> x__{_ConfigProto'logDevicePlacement = y__}))
              Prelude.id

instance (a ~ GraphOptions, b ~ GraphOptions, Prelude.Functor f) =>
         Lens.Labels.HasLens "graphOptions" f ConfigProto ConfigProto a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _ConfigProto'graphOptions
                 (\ x__ y__ -> x__{_ConfigProto'graphOptions = y__}))
              (Data.ProtoLens.maybeLens Data.Default.Class.def)

instance (a ~ Prelude.Maybe GraphOptions,
          b ~ Prelude.Maybe GraphOptions, Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'graphOptions" f ConfigProto ConfigProto
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _ConfigProto'graphOptions
                 (\ x__ y__ -> x__{_ConfigProto'graphOptions = y__}))
              Prelude.id

instance (a ~ Data.Int.Int64, b ~ Data.Int.Int64,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "operationTimeoutInMs" f ConfigProto
           ConfigProto
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _ConfigProto'operationTimeoutInMs
                 (\ x__ y__ -> x__{_ConfigProto'operationTimeoutInMs = y__}))
              Prelude.id

instance (a ~ RPCOptions, b ~ RPCOptions, Prelude.Functor f) =>
         Lens.Labels.HasLens "rpcOptions" f ConfigProto ConfigProto a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _ConfigProto'rpcOptions
                 (\ x__ y__ -> x__{_ConfigProto'rpcOptions = y__}))
              (Data.ProtoLens.maybeLens Data.Default.Class.def)

instance (a ~ Prelude.Maybe RPCOptions,
          b ~ Prelude.Maybe RPCOptions, Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'rpcOptions" f ConfigProto ConfigProto a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _ConfigProto'rpcOptions
                 (\ x__ y__ -> x__{_ConfigProto'rpcOptions = y__}))
              Prelude.id

instance (a ~ Proto.Tensorflow.Core.Protobuf.Cluster.ClusterDef,
          b ~ Proto.Tensorflow.Core.Protobuf.Cluster.ClusterDef,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "clusterDef" f ConfigProto ConfigProto a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _ConfigProto'clusterDef
                 (\ x__ y__ -> x__{_ConfigProto'clusterDef = y__}))
              (Data.ProtoLens.maybeLens Data.Default.Class.def)

instance (a ~
            Prelude.Maybe Proto.Tensorflow.Core.Protobuf.Cluster.ClusterDef,
          b ~
            Prelude.Maybe Proto.Tensorflow.Core.Protobuf.Cluster.ClusterDef,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'clusterDef" f ConfigProto ConfigProto a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _ConfigProto'clusterDef
                 (\ x__ y__ -> x__{_ConfigProto'clusterDef = y__}))
              Prelude.id

instance (a ~ Prelude.Bool, b ~ Prelude.Bool, Prelude.Functor f) =>
         Lens.Labels.HasLens "isolateSessionState" f ConfigProto ConfigProto
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _ConfigProto'isolateSessionState
                 (\ x__ y__ -> x__{_ConfigProto'isolateSessionState = y__}))
              Prelude.id

instance (a ~ ConfigProto'Experimental,
          b ~ ConfigProto'Experimental, Prelude.Functor f) =>
         Lens.Labels.HasLens "experimental" f ConfigProto ConfigProto a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _ConfigProto'experimental
                 (\ x__ y__ -> x__{_ConfigProto'experimental = y__}))
              (Data.ProtoLens.maybeLens Data.Default.Class.def)

instance (a ~ Prelude.Maybe ConfigProto'Experimental,
          b ~ Prelude.Maybe ConfigProto'Experimental, Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'experimental" f ConfigProto ConfigProto
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _ConfigProto'experimental
                 (\ x__ y__ -> x__{_ConfigProto'experimental = y__}))
              Prelude.id

instance Data.Default.Class.Default ConfigProto where
        def
          = ConfigProto{_ConfigProto'deviceCount = Data.Map.empty,
                        _ConfigProto'intraOpParallelismThreads =
                          Data.ProtoLens.fieldDefault,
                        _ConfigProto'interOpParallelismThreads =
                          Data.ProtoLens.fieldDefault,
                        _ConfigProto'usePerSessionThreads = Data.ProtoLens.fieldDefault,
                        _ConfigProto'sessionInterOpThreadPool = [],
                        _ConfigProto'placementPeriod = Data.ProtoLens.fieldDefault,
                        _ConfigProto'deviceFilters = [],
                        _ConfigProto'gpuOptions = Prelude.Nothing,
                        _ConfigProto'allowSoftPlacement = Data.ProtoLens.fieldDefault,
                        _ConfigProto'logDevicePlacement = Data.ProtoLens.fieldDefault,
                        _ConfigProto'graphOptions = Prelude.Nothing,
                        _ConfigProto'operationTimeoutInMs = Data.ProtoLens.fieldDefault,
                        _ConfigProto'rpcOptions = Prelude.Nothing,
                        _ConfigProto'clusterDef = Prelude.Nothing,
                        _ConfigProto'isolateSessionState = Data.ProtoLens.fieldDefault,
                        _ConfigProto'experimental = Prelude.Nothing}

instance Data.ProtoLens.Message ConfigProto where
        descriptor
          = let deviceCount__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "device_count"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor ConfigProto'DeviceCountEntry)
                      (Data.ProtoLens.MapField key value deviceCount)
                      :: Data.ProtoLens.FieldDescriptor ConfigProto
                intraOpParallelismThreads__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "intra_op_parallelism_threads"
                      (Data.ProtoLens.Int32Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         intraOpParallelismThreads)
                      :: Data.ProtoLens.FieldDescriptor ConfigProto
                interOpParallelismThreads__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "inter_op_parallelism_threads"
                      (Data.ProtoLens.Int32Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         interOpParallelismThreads)
                      :: Data.ProtoLens.FieldDescriptor ConfigProto
                usePerSessionThreads__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "use_per_session_threads"
                      (Data.ProtoLens.BoolField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         usePerSessionThreads)
                      :: Data.ProtoLens.FieldDescriptor ConfigProto
                sessionInterOpThreadPool__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "session_inter_op_thread_pool"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor ThreadPoolOptionProto)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked
                         sessionInterOpThreadPool)
                      :: Data.ProtoLens.FieldDescriptor ConfigProto
                placementPeriod__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "placement_period"
                      (Data.ProtoLens.Int32Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional placementPeriod)
                      :: Data.ProtoLens.FieldDescriptor ConfigProto
                deviceFilters__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "device_filters"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked
                         deviceFilters)
                      :: Data.ProtoLens.FieldDescriptor ConfigProto
                gpuOptions__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "gpu_options"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor GPUOptions)
                      (Data.ProtoLens.OptionalField maybe'gpuOptions)
                      :: Data.ProtoLens.FieldDescriptor ConfigProto
                allowSoftPlacement__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "allow_soft_placement"
                      (Data.ProtoLens.BoolField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         allowSoftPlacement)
                      :: Data.ProtoLens.FieldDescriptor ConfigProto
                logDevicePlacement__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "log_device_placement"
                      (Data.ProtoLens.BoolField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         logDevicePlacement)
                      :: Data.ProtoLens.FieldDescriptor ConfigProto
                graphOptions__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "graph_options"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor GraphOptions)
                      (Data.ProtoLens.OptionalField maybe'graphOptions)
                      :: Data.ProtoLens.FieldDescriptor ConfigProto
                operationTimeoutInMs__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "operation_timeout_in_ms"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         operationTimeoutInMs)
                      :: Data.ProtoLens.FieldDescriptor ConfigProto
                rpcOptions__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "rpc_options"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor RPCOptions)
                      (Data.ProtoLens.OptionalField maybe'rpcOptions)
                      :: Data.ProtoLens.FieldDescriptor ConfigProto
                clusterDef__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "cluster_def"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor
                           Proto.Tensorflow.Core.Protobuf.Cluster.ClusterDef)
                      (Data.ProtoLens.OptionalField maybe'clusterDef)
                      :: Data.ProtoLens.FieldDescriptor ConfigProto
                isolateSessionState__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "isolate_session_state"
                      (Data.ProtoLens.BoolField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         isolateSessionState)
                      :: Data.ProtoLens.FieldDescriptor ConfigProto
                experimental__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "experimental"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor ConfigProto'Experimental)
                      (Data.ProtoLens.OptionalField maybe'experimental)
                      :: Data.ProtoLens.FieldDescriptor ConfigProto
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.ConfigProto")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, deviceCount__field_descriptor),
                    (Data.ProtoLens.Tag 2,
                     intraOpParallelismThreads__field_descriptor),
                    (Data.ProtoLens.Tag 5,
                     interOpParallelismThreads__field_descriptor),
                    (Data.ProtoLens.Tag 9, usePerSessionThreads__field_descriptor),
                    (Data.ProtoLens.Tag 12,
                     sessionInterOpThreadPool__field_descriptor),
                    (Data.ProtoLens.Tag 3, placementPeriod__field_descriptor),
                    (Data.ProtoLens.Tag 4, deviceFilters__field_descriptor),
                    (Data.ProtoLens.Tag 6, gpuOptions__field_descriptor),
                    (Data.ProtoLens.Tag 7, allowSoftPlacement__field_descriptor),
                    (Data.ProtoLens.Tag 8, logDevicePlacement__field_descriptor),
                    (Data.ProtoLens.Tag 10, graphOptions__field_descriptor),
                    (Data.ProtoLens.Tag 11, operationTimeoutInMs__field_descriptor),
                    (Data.ProtoLens.Tag 13, rpcOptions__field_descriptor),
                    (Data.ProtoLens.Tag 14, clusterDef__field_descriptor),
                    (Data.ProtoLens.Tag 15, isolateSessionState__field_descriptor),
                    (Data.ProtoLens.Tag 16, experimental__field_descriptor)])
                (Data.Map.fromList
                   [("device_count", deviceCount__field_descriptor),
                    ("intra_op_parallelism_threads",
                     intraOpParallelismThreads__field_descriptor),
                    ("inter_op_parallelism_threads",
                     interOpParallelismThreads__field_descriptor),
                    ("use_per_session_threads",
                     usePerSessionThreads__field_descriptor),
                    ("session_inter_op_thread_pool",
                     sessionInterOpThreadPool__field_descriptor),
                    ("placement_period", placementPeriod__field_descriptor),
                    ("device_filters", deviceFilters__field_descriptor),
                    ("gpu_options", gpuOptions__field_descriptor),
                    ("allow_soft_placement", allowSoftPlacement__field_descriptor),
                    ("log_device_placement", logDevicePlacement__field_descriptor),
                    ("graph_options", graphOptions__field_descriptor),
                    ("operation_timeout_in_ms",
                     operationTimeoutInMs__field_descriptor),
                    ("rpc_options", rpcOptions__field_descriptor),
                    ("cluster_def", clusterDef__field_descriptor),
                    ("isolate_session_state", isolateSessionState__field_descriptor),
                    ("experimental", experimental__field_descriptor)])

data ConfigProto'DeviceCountEntry = ConfigProto'DeviceCountEntry{_ConfigProto'DeviceCountEntry'key
                                                                 :: !Data.Text.Text,
                                                                 _ConfigProto'DeviceCountEntry'value
                                                                 :: !Data.Int.Int32}
                                  deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance (a ~ Data.Text.Text, b ~ Data.Text.Text,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "key" f ConfigProto'DeviceCountEntry
           ConfigProto'DeviceCountEntry
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _ConfigProto'DeviceCountEntry'key
                 (\ x__ y__ -> x__{_ConfigProto'DeviceCountEntry'key = y__}))
              Prelude.id

instance (a ~ Data.Int.Int32, b ~ Data.Int.Int32,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "value" f ConfigProto'DeviceCountEntry
           ConfigProto'DeviceCountEntry
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _ConfigProto'DeviceCountEntry'value
                 (\ x__ y__ -> x__{_ConfigProto'DeviceCountEntry'value = y__}))
              Prelude.id

instance Data.Default.Class.Default ConfigProto'DeviceCountEntry
         where
        def
          = ConfigProto'DeviceCountEntry{_ConfigProto'DeviceCountEntry'key =
                                           Data.ProtoLens.fieldDefault,
                                         _ConfigProto'DeviceCountEntry'value =
                                           Data.ProtoLens.fieldDefault}

instance Data.ProtoLens.Message ConfigProto'DeviceCountEntry where
        descriptor
          = let key__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "key"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional key)
                      :: Data.ProtoLens.FieldDescriptor ConfigProto'DeviceCountEntry
                value__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "value"
                      (Data.ProtoLens.Int32Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional value)
                      :: Data.ProtoLens.FieldDescriptor ConfigProto'DeviceCountEntry
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.ConfigProto.DeviceCountEntry")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, key__field_descriptor),
                    (Data.ProtoLens.Tag 2, value__field_descriptor)])
                (Data.Map.fromList
                   [("key", key__field_descriptor),
                    ("value", value__field_descriptor)])

data ConfigProto'Experimental = ConfigProto'Experimental{_ConfigProto'Experimental'collectiveGroupLeader
                                                         :: !Data.Text.Text}
                              deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance (a ~ Data.Text.Text, b ~ Data.Text.Text,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "collectiveGroupLeader" f
           ConfigProto'Experimental
           ConfigProto'Experimental
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens
                 _ConfigProto'Experimental'collectiveGroupLeader
                 (\ x__ y__ ->
                    x__{_ConfigProto'Experimental'collectiveGroupLeader = y__}))
              Prelude.id

instance Data.Default.Class.Default ConfigProto'Experimental where
        def
          = ConfigProto'Experimental{_ConfigProto'Experimental'collectiveGroupLeader
                                       = Data.ProtoLens.fieldDefault}

instance Data.ProtoLens.Message ConfigProto'Experimental where
        descriptor
          = let collectiveGroupLeader__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "collective_group_leader"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         collectiveGroupLeader)
                      :: Data.ProtoLens.FieldDescriptor ConfigProto'Experimental
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.ConfigProto.Experimental")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, collectiveGroupLeader__field_descriptor)])
                (Data.Map.fromList
                   [("collective_group_leader",
                     collectiveGroupLeader__field_descriptor)])

data GPUOptions = GPUOptions{_GPUOptions'perProcessGpuMemoryFraction
                             :: !Prelude.Double,
                             _GPUOptions'allowGrowth :: !Prelude.Bool,
                             _GPUOptions'allocatorType :: !Data.Text.Text,
                             _GPUOptions'deferredDeletionBytes :: !Data.Int.Int64,
                             _GPUOptions'visibleDeviceList :: !Data.Text.Text,
                             _GPUOptions'pollingActiveDelayUsecs :: !Data.Int.Int32,
                             _GPUOptions'pollingInactiveDelayMsecs :: !Data.Int.Int32,
                             _GPUOptions'forceGpuCompatible :: !Prelude.Bool,
                             _GPUOptions'experimental ::
                             !(Prelude.Maybe GPUOptions'Experimental)}
                deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance (a ~ Prelude.Double, b ~ Prelude.Double,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "perProcessGpuMemoryFraction" f GPUOptions
           GPUOptions
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens
                 _GPUOptions'perProcessGpuMemoryFraction
                 (\ x__ y__ -> x__{_GPUOptions'perProcessGpuMemoryFraction = y__}))
              Prelude.id

instance (a ~ Prelude.Bool, b ~ Prelude.Bool, Prelude.Functor f) =>
         Lens.Labels.HasLens "allowGrowth" f GPUOptions GPUOptions a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _GPUOptions'allowGrowth
                 (\ x__ y__ -> x__{_GPUOptions'allowGrowth = y__}))
              Prelude.id

instance (a ~ Data.Text.Text, b ~ Data.Text.Text,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "allocatorType" f GPUOptions GPUOptions a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _GPUOptions'allocatorType
                 (\ x__ y__ -> x__{_GPUOptions'allocatorType = y__}))
              Prelude.id

instance (a ~ Data.Int.Int64, b ~ Data.Int.Int64,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "deferredDeletionBytes" f GPUOptions GPUOptions
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _GPUOptions'deferredDeletionBytes
                 (\ x__ y__ -> x__{_GPUOptions'deferredDeletionBytes = y__}))
              Prelude.id

instance (a ~ Data.Text.Text, b ~ Data.Text.Text,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "visibleDeviceList" f GPUOptions GPUOptions a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _GPUOptions'visibleDeviceList
                 (\ x__ y__ -> x__{_GPUOptions'visibleDeviceList = y__}))
              Prelude.id

instance (a ~ Data.Int.Int32, b ~ Data.Int.Int32,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "pollingActiveDelayUsecs" f GPUOptions
           GPUOptions
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _GPUOptions'pollingActiveDelayUsecs
                 (\ x__ y__ -> x__{_GPUOptions'pollingActiveDelayUsecs = y__}))
              Prelude.id

instance (a ~ Data.Int.Int32, b ~ Data.Int.Int32,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "pollingInactiveDelayMsecs" f GPUOptions
           GPUOptions
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _GPUOptions'pollingInactiveDelayMsecs
                 (\ x__ y__ -> x__{_GPUOptions'pollingInactiveDelayMsecs = y__}))
              Prelude.id

instance (a ~ Prelude.Bool, b ~ Prelude.Bool, Prelude.Functor f) =>
         Lens.Labels.HasLens "forceGpuCompatible" f GPUOptions GPUOptions a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _GPUOptions'forceGpuCompatible
                 (\ x__ y__ -> x__{_GPUOptions'forceGpuCompatible = y__}))
              Prelude.id

instance (a ~ GPUOptions'Experimental, b ~ GPUOptions'Experimental,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "experimental" f GPUOptions GPUOptions a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _GPUOptions'experimental
                 (\ x__ y__ -> x__{_GPUOptions'experimental = y__}))
              (Data.ProtoLens.maybeLens Data.Default.Class.def)

instance (a ~ Prelude.Maybe GPUOptions'Experimental,
          b ~ Prelude.Maybe GPUOptions'Experimental, Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'experimental" f GPUOptions GPUOptions a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _GPUOptions'experimental
                 (\ x__ y__ -> x__{_GPUOptions'experimental = y__}))
              Prelude.id

instance Data.Default.Class.Default GPUOptions where
        def
          = GPUOptions{_GPUOptions'perProcessGpuMemoryFraction =
                         Data.ProtoLens.fieldDefault,
                       _GPUOptions'allowGrowth = Data.ProtoLens.fieldDefault,
                       _GPUOptions'allocatorType = Data.ProtoLens.fieldDefault,
                       _GPUOptions'deferredDeletionBytes = Data.ProtoLens.fieldDefault,
                       _GPUOptions'visibleDeviceList = Data.ProtoLens.fieldDefault,
                       _GPUOptions'pollingActiveDelayUsecs = Data.ProtoLens.fieldDefault,
                       _GPUOptions'pollingInactiveDelayMsecs =
                         Data.ProtoLens.fieldDefault,
                       _GPUOptions'forceGpuCompatible = Data.ProtoLens.fieldDefault,
                       _GPUOptions'experimental = Prelude.Nothing}

instance Data.ProtoLens.Message GPUOptions where
        descriptor
          = let perProcessGpuMemoryFraction__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "per_process_gpu_memory_fraction"
                      (Data.ProtoLens.DoubleField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Double)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         perProcessGpuMemoryFraction)
                      :: Data.ProtoLens.FieldDescriptor GPUOptions
                allowGrowth__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "allow_growth"
                      (Data.ProtoLens.BoolField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional allowGrowth)
                      :: Data.ProtoLens.FieldDescriptor GPUOptions
                allocatorType__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "allocator_type"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional allocatorType)
                      :: Data.ProtoLens.FieldDescriptor GPUOptions
                deferredDeletionBytes__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "deferred_deletion_bytes"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         deferredDeletionBytes)
                      :: Data.ProtoLens.FieldDescriptor GPUOptions
                visibleDeviceList__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "visible_device_list"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         visibleDeviceList)
                      :: Data.ProtoLens.FieldDescriptor GPUOptions
                pollingActiveDelayUsecs__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "polling_active_delay_usecs"
                      (Data.ProtoLens.Int32Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         pollingActiveDelayUsecs)
                      :: Data.ProtoLens.FieldDescriptor GPUOptions
                pollingInactiveDelayMsecs__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "polling_inactive_delay_msecs"
                      (Data.ProtoLens.Int32Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         pollingInactiveDelayMsecs)
                      :: Data.ProtoLens.FieldDescriptor GPUOptions
                forceGpuCompatible__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "force_gpu_compatible"
                      (Data.ProtoLens.BoolField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         forceGpuCompatible)
                      :: Data.ProtoLens.FieldDescriptor GPUOptions
                experimental__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "experimental"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor GPUOptions'Experimental)
                      (Data.ProtoLens.OptionalField maybe'experimental)
                      :: Data.ProtoLens.FieldDescriptor GPUOptions
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.GPUOptions")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1,
                     perProcessGpuMemoryFraction__field_descriptor),
                    (Data.ProtoLens.Tag 4, allowGrowth__field_descriptor),
                    (Data.ProtoLens.Tag 2, allocatorType__field_descriptor),
                    (Data.ProtoLens.Tag 3, deferredDeletionBytes__field_descriptor),
                    (Data.ProtoLens.Tag 5, visibleDeviceList__field_descriptor),
                    (Data.ProtoLens.Tag 6, pollingActiveDelayUsecs__field_descriptor),
                    (Data.ProtoLens.Tag 7,
                     pollingInactiveDelayMsecs__field_descriptor),
                    (Data.ProtoLens.Tag 8, forceGpuCompatible__field_descriptor),
                    (Data.ProtoLens.Tag 9, experimental__field_descriptor)])
                (Data.Map.fromList
                   [("per_process_gpu_memory_fraction",
                     perProcessGpuMemoryFraction__field_descriptor),
                    ("allow_growth", allowGrowth__field_descriptor),
                    ("allocator_type", allocatorType__field_descriptor),
                    ("deferred_deletion_bytes",
                     deferredDeletionBytes__field_descriptor),
                    ("visible_device_list", visibleDeviceList__field_descriptor),
                    ("polling_active_delay_usecs",
                     pollingActiveDelayUsecs__field_descriptor),
                    ("polling_inactive_delay_msecs",
                     pollingInactiveDelayMsecs__field_descriptor),
                    ("force_gpu_compatible", forceGpuCompatible__field_descriptor),
                    ("experimental", experimental__field_descriptor)])

data GPUOptions'Experimental = GPUOptions'Experimental{_GPUOptions'Experimental'virtualDevices
                                                       :: ![GPUOptions'Experimental'VirtualDevices],
                                                       _GPUOptions'Experimental'useUnifiedMemory ::
                                                       !Prelude.Bool}
                             deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance (a ~ [GPUOptions'Experimental'VirtualDevices],
          b ~ [GPUOptions'Experimental'VirtualDevices], Prelude.Functor f) =>
         Lens.Labels.HasLens "virtualDevices" f GPUOptions'Experimental
           GPUOptions'Experimental
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens
                 _GPUOptions'Experimental'virtualDevices
                 (\ x__ y__ -> x__{_GPUOptions'Experimental'virtualDevices = y__}))
              Prelude.id

instance (a ~ Prelude.Bool, b ~ Prelude.Bool, Prelude.Functor f) =>
         Lens.Labels.HasLens "useUnifiedMemory" f GPUOptions'Experimental
           GPUOptions'Experimental
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens
                 _GPUOptions'Experimental'useUnifiedMemory
                 (\ x__ y__ ->
                    x__{_GPUOptions'Experimental'useUnifiedMemory = y__}))
              Prelude.id

instance Data.Default.Class.Default GPUOptions'Experimental where
        def
          = GPUOptions'Experimental{_GPUOptions'Experimental'virtualDevices =
                                      [],
                                    _GPUOptions'Experimental'useUnifiedMemory =
                                      Data.ProtoLens.fieldDefault}

instance Data.ProtoLens.Message GPUOptions'Experimental where
        descriptor
          = let virtualDevices__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "virtual_devices"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor
                           GPUOptions'Experimental'VirtualDevices)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked
                         virtualDevices)
                      :: Data.ProtoLens.FieldDescriptor GPUOptions'Experimental
                useUnifiedMemory__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "use_unified_memory"
                      (Data.ProtoLens.BoolField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         useUnifiedMemory)
                      :: Data.ProtoLens.FieldDescriptor GPUOptions'Experimental
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.GPUOptions.Experimental")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, virtualDevices__field_descriptor),
                    (Data.ProtoLens.Tag 2, useUnifiedMemory__field_descriptor)])
                (Data.Map.fromList
                   [("virtual_devices", virtualDevices__field_descriptor),
                    ("use_unified_memory", useUnifiedMemory__field_descriptor)])

data GPUOptions'Experimental'VirtualDevices = GPUOptions'Experimental'VirtualDevices{_GPUOptions'Experimental'VirtualDevices'memoryLimitMb
                                                                                     ::
                                                                                     ![Prelude.Float]}
                                            deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance (a ~ [Prelude.Float], b ~ [Prelude.Float],
          Prelude.Functor f) =>
         Lens.Labels.HasLens "memoryLimitMb" f
           GPUOptions'Experimental'VirtualDevices
           GPUOptions'Experimental'VirtualDevices
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens
                 _GPUOptions'Experimental'VirtualDevices'memoryLimitMb
                 (\ x__ y__ ->
                    x__{_GPUOptions'Experimental'VirtualDevices'memoryLimitMb = y__}))
              Prelude.id

instance Data.Default.Class.Default
           GPUOptions'Experimental'VirtualDevices
         where
        def
          = GPUOptions'Experimental'VirtualDevices{_GPUOptions'Experimental'VirtualDevices'memoryLimitMb
                                                     = []}

instance Data.ProtoLens.Message
           GPUOptions'Experimental'VirtualDevices
         where
        descriptor
          = let memoryLimitMb__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "memory_limit_mb"
                      (Data.ProtoLens.FloatField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Float)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Packed memoryLimitMb)
                      ::
                      Data.ProtoLens.FieldDescriptor
                        GPUOptions'Experimental'VirtualDevices
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack
                   "tensorflow.GPUOptions.Experimental.VirtualDevices")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, memoryLimitMb__field_descriptor)])
                (Data.Map.fromList
                   [("memory_limit_mb", memoryLimitMb__field_descriptor)])

data GraphOptions = GraphOptions{_GraphOptions'enableRecvScheduling
                                 :: !Prelude.Bool,
                                 _GraphOptions'optimizerOptions ::
                                 !(Prelude.Maybe OptimizerOptions),
                                 _GraphOptions'buildCostModel :: !Data.Int.Int64,
                                 _GraphOptions'buildCostModelAfter :: !Data.Int.Int64,
                                 _GraphOptions'inferShapes :: !Prelude.Bool,
                                 _GraphOptions'placePrunedGraph :: !Prelude.Bool,
                                 _GraphOptions'enableBfloat16Sendrecv :: !Prelude.Bool,
                                 _GraphOptions'timelineStep :: !Data.Int.Int32,
                                 _GraphOptions'rewriteOptions ::
                                 !(Prelude.Maybe
                                     Proto.Tensorflow.Core.Protobuf.RewriterConfig.RewriterConfig)}
                  deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance (a ~ Prelude.Bool, b ~ Prelude.Bool, Prelude.Functor f) =>
         Lens.Labels.HasLens "enableRecvScheduling" f GraphOptions
           GraphOptions
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _GraphOptions'enableRecvScheduling
                 (\ x__ y__ -> x__{_GraphOptions'enableRecvScheduling = y__}))
              Prelude.id

instance (a ~ OptimizerOptions, b ~ OptimizerOptions,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "optimizerOptions" f GraphOptions GraphOptions
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _GraphOptions'optimizerOptions
                 (\ x__ y__ -> x__{_GraphOptions'optimizerOptions = y__}))
              (Data.ProtoLens.maybeLens Data.Default.Class.def)

instance (a ~ Prelude.Maybe OptimizerOptions,
          b ~ Prelude.Maybe OptimizerOptions, Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'optimizerOptions" f GraphOptions
           GraphOptions
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _GraphOptions'optimizerOptions
                 (\ x__ y__ -> x__{_GraphOptions'optimizerOptions = y__}))
              Prelude.id

instance (a ~ Data.Int.Int64, b ~ Data.Int.Int64,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "buildCostModel" f GraphOptions GraphOptions a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _GraphOptions'buildCostModel
                 (\ x__ y__ -> x__{_GraphOptions'buildCostModel = y__}))
              Prelude.id

instance (a ~ Data.Int.Int64, b ~ Data.Int.Int64,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "buildCostModelAfter" f GraphOptions
           GraphOptions
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _GraphOptions'buildCostModelAfter
                 (\ x__ y__ -> x__{_GraphOptions'buildCostModelAfter = y__}))
              Prelude.id

instance (a ~ Prelude.Bool, b ~ Prelude.Bool, Prelude.Functor f) =>
         Lens.Labels.HasLens "inferShapes" f GraphOptions GraphOptions a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _GraphOptions'inferShapes
                 (\ x__ y__ -> x__{_GraphOptions'inferShapes = y__}))
              Prelude.id

instance (a ~ Prelude.Bool, b ~ Prelude.Bool, Prelude.Functor f) =>
         Lens.Labels.HasLens "placePrunedGraph" f GraphOptions GraphOptions
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _GraphOptions'placePrunedGraph
                 (\ x__ y__ -> x__{_GraphOptions'placePrunedGraph = y__}))
              Prelude.id

instance (a ~ Prelude.Bool, b ~ Prelude.Bool, Prelude.Functor f) =>
         Lens.Labels.HasLens "enableBfloat16Sendrecv" f GraphOptions
           GraphOptions
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _GraphOptions'enableBfloat16Sendrecv
                 (\ x__ y__ -> x__{_GraphOptions'enableBfloat16Sendrecv = y__}))
              Prelude.id

instance (a ~ Data.Int.Int32, b ~ Data.Int.Int32,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "timelineStep" f GraphOptions GraphOptions a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _GraphOptions'timelineStep
                 (\ x__ y__ -> x__{_GraphOptions'timelineStep = y__}))
              Prelude.id

instance (a ~
            Proto.Tensorflow.Core.Protobuf.RewriterConfig.RewriterConfig,
          b ~ Proto.Tensorflow.Core.Protobuf.RewriterConfig.RewriterConfig,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "rewriteOptions" f GraphOptions GraphOptions a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _GraphOptions'rewriteOptions
                 (\ x__ y__ -> x__{_GraphOptions'rewriteOptions = y__}))
              (Data.ProtoLens.maybeLens Data.Default.Class.def)

instance (a ~
            Prelude.Maybe
              Proto.Tensorflow.Core.Protobuf.RewriterConfig.RewriterConfig,
          b ~
            Prelude.Maybe
              Proto.Tensorflow.Core.Protobuf.RewriterConfig.RewriterConfig,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'rewriteOptions" f GraphOptions
           GraphOptions
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _GraphOptions'rewriteOptions
                 (\ x__ y__ -> x__{_GraphOptions'rewriteOptions = y__}))
              Prelude.id

instance Data.Default.Class.Default GraphOptions where
        def
          = GraphOptions{_GraphOptions'enableRecvScheduling =
                           Data.ProtoLens.fieldDefault,
                         _GraphOptions'optimizerOptions = Prelude.Nothing,
                         _GraphOptions'buildCostModel = Data.ProtoLens.fieldDefault,
                         _GraphOptions'buildCostModelAfter = Data.ProtoLens.fieldDefault,
                         _GraphOptions'inferShapes = Data.ProtoLens.fieldDefault,
                         _GraphOptions'placePrunedGraph = Data.ProtoLens.fieldDefault,
                         _GraphOptions'enableBfloat16Sendrecv = Data.ProtoLens.fieldDefault,
                         _GraphOptions'timelineStep = Data.ProtoLens.fieldDefault,
                         _GraphOptions'rewriteOptions = Prelude.Nothing}

instance Data.ProtoLens.Message GraphOptions where
        descriptor
          = let enableRecvScheduling__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "enable_recv_scheduling"
                      (Data.ProtoLens.BoolField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         enableRecvScheduling)
                      :: Data.ProtoLens.FieldDescriptor GraphOptions
                optimizerOptions__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "optimizer_options"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor OptimizerOptions)
                      (Data.ProtoLens.OptionalField maybe'optimizerOptions)
                      :: Data.ProtoLens.FieldDescriptor GraphOptions
                buildCostModel__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "build_cost_model"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional buildCostModel)
                      :: Data.ProtoLens.FieldDescriptor GraphOptions
                buildCostModelAfter__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "build_cost_model_after"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         buildCostModelAfter)
                      :: Data.ProtoLens.FieldDescriptor GraphOptions
                inferShapes__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "infer_shapes"
                      (Data.ProtoLens.BoolField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional inferShapes)
                      :: Data.ProtoLens.FieldDescriptor GraphOptions
                placePrunedGraph__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "place_pruned_graph"
                      (Data.ProtoLens.BoolField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         placePrunedGraph)
                      :: Data.ProtoLens.FieldDescriptor GraphOptions
                enableBfloat16Sendrecv__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "enable_bfloat16_sendrecv"
                      (Data.ProtoLens.BoolField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         enableBfloat16Sendrecv)
                      :: Data.ProtoLens.FieldDescriptor GraphOptions
                timelineStep__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "timeline_step"
                      (Data.ProtoLens.Int32Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional timelineStep)
                      :: Data.ProtoLens.FieldDescriptor GraphOptions
                rewriteOptions__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "rewrite_options"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor
                           Proto.Tensorflow.Core.Protobuf.RewriterConfig.RewriterConfig)
                      (Data.ProtoLens.OptionalField maybe'rewriteOptions)
                      :: Data.ProtoLens.FieldDescriptor GraphOptions
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.GraphOptions")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 2, enableRecvScheduling__field_descriptor),
                    (Data.ProtoLens.Tag 3, optimizerOptions__field_descriptor),
                    (Data.ProtoLens.Tag 4, buildCostModel__field_descriptor),
                    (Data.ProtoLens.Tag 9, buildCostModelAfter__field_descriptor),
                    (Data.ProtoLens.Tag 5, inferShapes__field_descriptor),
                    (Data.ProtoLens.Tag 6, placePrunedGraph__field_descriptor),
                    (Data.ProtoLens.Tag 7, enableBfloat16Sendrecv__field_descriptor),
                    (Data.ProtoLens.Tag 8, timelineStep__field_descriptor),
                    (Data.ProtoLens.Tag 10, rewriteOptions__field_descriptor)])
                (Data.Map.fromList
                   [("enable_recv_scheduling",
                     enableRecvScheduling__field_descriptor),
                    ("optimizer_options", optimizerOptions__field_descriptor),
                    ("build_cost_model", buildCostModel__field_descriptor),
                    ("build_cost_model_after", buildCostModelAfter__field_descriptor),
                    ("infer_shapes", inferShapes__field_descriptor),
                    ("place_pruned_graph", placePrunedGraph__field_descriptor),
                    ("enable_bfloat16_sendrecv",
                     enableBfloat16Sendrecv__field_descriptor),
                    ("timeline_step", timelineStep__field_descriptor),
                    ("rewrite_options", rewriteOptions__field_descriptor)])

data OptimizerOptions = OptimizerOptions{_OptimizerOptions'doCommonSubexpressionElimination
                                         :: !Prelude.Bool,
                                         _OptimizerOptions'doConstantFolding :: !Prelude.Bool,
                                         _OptimizerOptions'maxFoldedConstantInBytes ::
                                         !Data.Int.Int64,
                                         _OptimizerOptions'doFunctionInlining :: !Prelude.Bool,
                                         _OptimizerOptions'optLevel :: !OptimizerOptions'Level,
                                         _OptimizerOptions'globalJitLevel ::
                                         !OptimizerOptions'GlobalJitLevel}
                      deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance (a ~ Prelude.Bool, b ~ Prelude.Bool, Prelude.Functor f) =>
         Lens.Labels.HasLens "doCommonSubexpressionElimination" f
           OptimizerOptions
           OptimizerOptions
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens
                 _OptimizerOptions'doCommonSubexpressionElimination
                 (\ x__ y__ ->
                    x__{_OptimizerOptions'doCommonSubexpressionElimination = y__}))
              Prelude.id

instance (a ~ Prelude.Bool, b ~ Prelude.Bool, Prelude.Functor f) =>
         Lens.Labels.HasLens "doConstantFolding" f OptimizerOptions
           OptimizerOptions
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _OptimizerOptions'doConstantFolding
                 (\ x__ y__ -> x__{_OptimizerOptions'doConstantFolding = y__}))
              Prelude.id

instance (a ~ Data.Int.Int64, b ~ Data.Int.Int64,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "maxFoldedConstantInBytes" f OptimizerOptions
           OptimizerOptions
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens
                 _OptimizerOptions'maxFoldedConstantInBytes
                 (\ x__ y__ ->
                    x__{_OptimizerOptions'maxFoldedConstantInBytes = y__}))
              Prelude.id

instance (a ~ Prelude.Bool, b ~ Prelude.Bool, Prelude.Functor f) =>
         Lens.Labels.HasLens "doFunctionInlining" f OptimizerOptions
           OptimizerOptions
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _OptimizerOptions'doFunctionInlining
                 (\ x__ y__ -> x__{_OptimizerOptions'doFunctionInlining = y__}))
              Prelude.id

instance (a ~ OptimizerOptions'Level, b ~ OptimizerOptions'Level,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "optLevel" f OptimizerOptions OptimizerOptions
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _OptimizerOptions'optLevel
                 (\ x__ y__ -> x__{_OptimizerOptions'optLevel = y__}))
              Prelude.id

instance (a ~ OptimizerOptions'GlobalJitLevel,
          b ~ OptimizerOptions'GlobalJitLevel, Prelude.Functor f) =>
         Lens.Labels.HasLens "globalJitLevel" f OptimizerOptions
           OptimizerOptions
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _OptimizerOptions'globalJitLevel
                 (\ x__ y__ -> x__{_OptimizerOptions'globalJitLevel = y__}))
              Prelude.id

instance Data.Default.Class.Default OptimizerOptions where
        def
          = OptimizerOptions{_OptimizerOptions'doCommonSubexpressionElimination
                               = Data.ProtoLens.fieldDefault,
                             _OptimizerOptions'doConstantFolding = Data.ProtoLens.fieldDefault,
                             _OptimizerOptions'maxFoldedConstantInBytes =
                               Data.ProtoLens.fieldDefault,
                             _OptimizerOptions'doFunctionInlining = Data.ProtoLens.fieldDefault,
                             _OptimizerOptions'optLevel = Data.Default.Class.def,
                             _OptimizerOptions'globalJitLevel = Data.Default.Class.def}

instance Data.ProtoLens.Message OptimizerOptions where
        descriptor
          = let doCommonSubexpressionElimination__field_descriptor
                  = Data.ProtoLens.FieldDescriptor
                      "do_common_subexpression_elimination"
                      (Data.ProtoLens.BoolField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         doCommonSubexpressionElimination)
                      :: Data.ProtoLens.FieldDescriptor OptimizerOptions
                doConstantFolding__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "do_constant_folding"
                      (Data.ProtoLens.BoolField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         doConstantFolding)
                      :: Data.ProtoLens.FieldDescriptor OptimizerOptions
                maxFoldedConstantInBytes__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "max_folded_constant_in_bytes"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         maxFoldedConstantInBytes)
                      :: Data.ProtoLens.FieldDescriptor OptimizerOptions
                doFunctionInlining__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "do_function_inlining"
                      (Data.ProtoLens.BoolField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         doFunctionInlining)
                      :: Data.ProtoLens.FieldDescriptor OptimizerOptions
                optLevel__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "opt_level"
                      (Data.ProtoLens.EnumField ::
                         Data.ProtoLens.FieldTypeDescriptor OptimizerOptions'Level)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional optLevel)
                      :: Data.ProtoLens.FieldDescriptor OptimizerOptions
                globalJitLevel__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "global_jit_level"
                      (Data.ProtoLens.EnumField ::
                         Data.ProtoLens.FieldTypeDescriptor OptimizerOptions'GlobalJitLevel)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional globalJitLevel)
                      :: Data.ProtoLens.FieldDescriptor OptimizerOptions
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.OptimizerOptions")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1,
                     doCommonSubexpressionElimination__field_descriptor),
                    (Data.ProtoLens.Tag 2, doConstantFolding__field_descriptor),
                    (Data.ProtoLens.Tag 6, maxFoldedConstantInBytes__field_descriptor),
                    (Data.ProtoLens.Tag 4, doFunctionInlining__field_descriptor),
                    (Data.ProtoLens.Tag 3, optLevel__field_descriptor),
                    (Data.ProtoLens.Tag 5, globalJitLevel__field_descriptor)])
                (Data.Map.fromList
                   [("do_common_subexpression_elimination",
                     doCommonSubexpressionElimination__field_descriptor),
                    ("do_constant_folding", doConstantFolding__field_descriptor),
                    ("max_folded_constant_in_bytes",
                     maxFoldedConstantInBytes__field_descriptor),
                    ("do_function_inlining", doFunctionInlining__field_descriptor),
                    ("opt_level", optLevel__field_descriptor),
                    ("global_jit_level", globalJitLevel__field_descriptor)])

data OptimizerOptions'GlobalJitLevel = OptimizerOptions'OFF
                                     | OptimizerOptions'DEFAULT
                                     | OptimizerOptions'ON_1
                                     | OptimizerOptions'ON_2
                                     deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance Data.Default.Class.Default OptimizerOptions'GlobalJitLevel
         where
        def = OptimizerOptions'OFF

instance Data.ProtoLens.FieldDefault
           OptimizerOptions'GlobalJitLevel
         where
        fieldDefault = OptimizerOptions'OFF

instance Data.ProtoLens.MessageEnum OptimizerOptions'GlobalJitLevel
         where
        maybeToEnum (-1) = Prelude.Just OptimizerOptions'OFF
        maybeToEnum 0 = Prelude.Just OptimizerOptions'DEFAULT
        maybeToEnum 1 = Prelude.Just OptimizerOptions'ON_1
        maybeToEnum 2 = Prelude.Just OptimizerOptions'ON_2
        maybeToEnum _ = Prelude.Nothing
        showEnum OptimizerOptions'OFF = "OFF"
        showEnum OptimizerOptions'DEFAULT = "DEFAULT"
        showEnum OptimizerOptions'ON_1 = "ON_1"
        showEnum OptimizerOptions'ON_2 = "ON_2"
        readEnum "OFF" = Prelude.Just OptimizerOptions'OFF
        readEnum "DEFAULT" = Prelude.Just OptimizerOptions'DEFAULT
        readEnum "ON_1" = Prelude.Just OptimizerOptions'ON_1
        readEnum "ON_2" = Prelude.Just OptimizerOptions'ON_2
        readEnum _ = Prelude.Nothing

instance Prelude.Enum OptimizerOptions'GlobalJitLevel where
        toEnum k__
          = Prelude.maybe
              (Prelude.error
                 ((Prelude.++) "toEnum: unknown value for enum GlobalJitLevel: "
                    (Prelude.show k__)))
              Prelude.id
              (Data.ProtoLens.maybeToEnum k__)
        fromEnum OptimizerOptions'OFF = -1
        fromEnum OptimizerOptions'DEFAULT = 0
        fromEnum OptimizerOptions'ON_1 = 1
        fromEnum OptimizerOptions'ON_2 = 2
        succ OptimizerOptions'ON_2
          = Prelude.error
              "OptimizerOptions'GlobalJitLevel.succ: bad argument OptimizerOptions'ON_2. This value would be out of bounds."
        succ OptimizerOptions'OFF = OptimizerOptions'DEFAULT
        succ OptimizerOptions'DEFAULT = OptimizerOptions'ON_1
        succ OptimizerOptions'ON_1 = OptimizerOptions'ON_2
        pred OptimizerOptions'OFF
          = Prelude.error
              "OptimizerOptions'GlobalJitLevel.pred: bad argument OptimizerOptions'OFF. This value would be out of bounds."
        pred OptimizerOptions'DEFAULT = OptimizerOptions'OFF
        pred OptimizerOptions'ON_1 = OptimizerOptions'DEFAULT
        pred OptimizerOptions'ON_2 = OptimizerOptions'ON_1
        enumFrom = Data.ProtoLens.Message.Enum.messageEnumFrom
        enumFromTo = Data.ProtoLens.Message.Enum.messageEnumFromTo
        enumFromThen = Data.ProtoLens.Message.Enum.messageEnumFromThen
        enumFromThenTo = Data.ProtoLens.Message.Enum.messageEnumFromThenTo

instance Prelude.Bounded OptimizerOptions'GlobalJitLevel where
        minBound = OptimizerOptions'OFF
        maxBound = OptimizerOptions'ON_2

data OptimizerOptions'Level = OptimizerOptions'L0
                            | OptimizerOptions'L1
                            deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance Data.Default.Class.Default OptimizerOptions'Level where
        def = OptimizerOptions'L0

instance Data.ProtoLens.FieldDefault OptimizerOptions'Level where
        fieldDefault = OptimizerOptions'L0

instance Data.ProtoLens.MessageEnum OptimizerOptions'Level where
        maybeToEnum (-1) = Prelude.Just OptimizerOptions'L0
        maybeToEnum 0 = Prelude.Just OptimizerOptions'L1
        maybeToEnum _ = Prelude.Nothing
        showEnum OptimizerOptions'L0 = "L0"
        showEnum OptimizerOptions'L1 = "L1"
        readEnum "L0" = Prelude.Just OptimizerOptions'L0
        readEnum "L1" = Prelude.Just OptimizerOptions'L1
        readEnum _ = Prelude.Nothing

instance Prelude.Enum OptimizerOptions'Level where
        toEnum k__
          = Prelude.maybe
              (Prelude.error
                 ((Prelude.++) "toEnum: unknown value for enum Level: "
                    (Prelude.show k__)))
              Prelude.id
              (Data.ProtoLens.maybeToEnum k__)
        fromEnum OptimizerOptions'L0 = -1
        fromEnum OptimizerOptions'L1 = 0
        succ OptimizerOptions'L1
          = Prelude.error
              "OptimizerOptions'Level.succ: bad argument OptimizerOptions'L1. This value would be out of bounds."
        succ OptimizerOptions'L0 = OptimizerOptions'L1
        pred OptimizerOptions'L0
          = Prelude.error
              "OptimizerOptions'Level.pred: bad argument OptimizerOptions'L0. This value would be out of bounds."
        pred OptimizerOptions'L1 = OptimizerOptions'L0
        enumFrom = Data.ProtoLens.Message.Enum.messageEnumFrom
        enumFromTo = Data.ProtoLens.Message.Enum.messageEnumFromTo
        enumFromThen = Data.ProtoLens.Message.Enum.messageEnumFromThen
        enumFromThenTo = Data.ProtoLens.Message.Enum.messageEnumFromThenTo

instance Prelude.Bounded OptimizerOptions'Level where
        minBound = OptimizerOptions'L0
        maxBound = OptimizerOptions'L1

data RPCOptions = RPCOptions{_RPCOptions'useRpcForInprocessMaster
                             :: !Prelude.Bool}
                deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance (a ~ Prelude.Bool, b ~ Prelude.Bool, Prelude.Functor f) =>
         Lens.Labels.HasLens "useRpcForInprocessMaster" f RPCOptions
           RPCOptions
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _RPCOptions'useRpcForInprocessMaster
                 (\ x__ y__ -> x__{_RPCOptions'useRpcForInprocessMaster = y__}))
              Prelude.id

instance Data.Default.Class.Default RPCOptions where
        def
          = RPCOptions{_RPCOptions'useRpcForInprocessMaster =
                         Data.ProtoLens.fieldDefault}

instance Data.ProtoLens.Message RPCOptions where
        descriptor
          = let useRpcForInprocessMaster__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "use_rpc_for_inprocess_master"
                      (Data.ProtoLens.BoolField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         useRpcForInprocessMaster)
                      :: Data.ProtoLens.FieldDescriptor RPCOptions
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.RPCOptions")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1,
                     useRpcForInprocessMaster__field_descriptor)])
                (Data.Map.fromList
                   [("use_rpc_for_inprocess_master",
                     useRpcForInprocessMaster__field_descriptor)])

data RunMetadata = RunMetadata{_RunMetadata'stepStats ::
                               !(Prelude.Maybe
                                   Proto.Tensorflow.Core.Framework.StepStats.StepStats),
                               _RunMetadata'costGraph ::
                               !(Prelude.Maybe
                                   Proto.Tensorflow.Core.Framework.CostGraph.CostGraphDef),
                               _RunMetadata'partitionGraphs ::
                               ![Proto.Tensorflow.Core.Framework.Graph.GraphDef]}
                 deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance (a ~ Proto.Tensorflow.Core.Framework.StepStats.StepStats,
          b ~ Proto.Tensorflow.Core.Framework.StepStats.StepStats,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "stepStats" f RunMetadata RunMetadata a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _RunMetadata'stepStats
                 (\ x__ y__ -> x__{_RunMetadata'stepStats = y__}))
              (Data.ProtoLens.maybeLens Data.Default.Class.def)

instance (a ~
            Prelude.Maybe Proto.Tensorflow.Core.Framework.StepStats.StepStats,
          b ~
            Prelude.Maybe Proto.Tensorflow.Core.Framework.StepStats.StepStats,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'stepStats" f RunMetadata RunMetadata a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _RunMetadata'stepStats
                 (\ x__ y__ -> x__{_RunMetadata'stepStats = y__}))
              Prelude.id

instance (a ~
            Proto.Tensorflow.Core.Framework.CostGraph.CostGraphDef,
          b ~ Proto.Tensorflow.Core.Framework.CostGraph.CostGraphDef,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "costGraph" f RunMetadata RunMetadata a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _RunMetadata'costGraph
                 (\ x__ y__ -> x__{_RunMetadata'costGraph = y__}))
              (Data.ProtoLens.maybeLens Data.Default.Class.def)

instance (a ~
            Prelude.Maybe
              Proto.Tensorflow.Core.Framework.CostGraph.CostGraphDef,
          b ~
            Prelude.Maybe
              Proto.Tensorflow.Core.Framework.CostGraph.CostGraphDef,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'costGraph" f RunMetadata RunMetadata a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _RunMetadata'costGraph
                 (\ x__ y__ -> x__{_RunMetadata'costGraph = y__}))
              Prelude.id

instance (a ~ [Proto.Tensorflow.Core.Framework.Graph.GraphDef],
          b ~ [Proto.Tensorflow.Core.Framework.Graph.GraphDef],
          Prelude.Functor f) =>
         Lens.Labels.HasLens "partitionGraphs" f RunMetadata RunMetadata a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _RunMetadata'partitionGraphs
                 (\ x__ y__ -> x__{_RunMetadata'partitionGraphs = y__}))
              Prelude.id

instance Data.Default.Class.Default RunMetadata where
        def
          = RunMetadata{_RunMetadata'stepStats = Prelude.Nothing,
                        _RunMetadata'costGraph = Prelude.Nothing,
                        _RunMetadata'partitionGraphs = []}

instance Data.ProtoLens.Message RunMetadata where
        descriptor
          = let stepStats__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "step_stats"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor
                           Proto.Tensorflow.Core.Framework.StepStats.StepStats)
                      (Data.ProtoLens.OptionalField maybe'stepStats)
                      :: Data.ProtoLens.FieldDescriptor RunMetadata
                costGraph__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "cost_graph"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor
                           Proto.Tensorflow.Core.Framework.CostGraph.CostGraphDef)
                      (Data.ProtoLens.OptionalField maybe'costGraph)
                      :: Data.ProtoLens.FieldDescriptor RunMetadata
                partitionGraphs__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "partition_graphs"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor
                           Proto.Tensorflow.Core.Framework.Graph.GraphDef)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked
                         partitionGraphs)
                      :: Data.ProtoLens.FieldDescriptor RunMetadata
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.RunMetadata")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, stepStats__field_descriptor),
                    (Data.ProtoLens.Tag 2, costGraph__field_descriptor),
                    (Data.ProtoLens.Tag 3, partitionGraphs__field_descriptor)])
                (Data.Map.fromList
                   [("step_stats", stepStats__field_descriptor),
                    ("cost_graph", costGraph__field_descriptor),
                    ("partition_graphs", partitionGraphs__field_descriptor)])

data RunOptions = RunOptions{_RunOptions'traceLevel ::
                             !RunOptions'TraceLevel,
                             _RunOptions'timeoutInMs :: !Data.Int.Int64,
                             _RunOptions'interOpThreadPool :: !Data.Int.Int32,
                             _RunOptions'outputPartitionGraphs :: !Prelude.Bool,
                             _RunOptions'debugOptions ::
                             !(Prelude.Maybe Proto.Tensorflow.Core.Protobuf.Debug.DebugOptions),
                             _RunOptions'reportTensorAllocationsUponOom :: !Prelude.Bool,
                             _RunOptions'experimental ::
                             !(Prelude.Maybe RunOptions'Experimental)}
                deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance (a ~ RunOptions'TraceLevel, b ~ RunOptions'TraceLevel,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "traceLevel" f RunOptions RunOptions a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _RunOptions'traceLevel
                 (\ x__ y__ -> x__{_RunOptions'traceLevel = y__}))
              Prelude.id

instance (a ~ Data.Int.Int64, b ~ Data.Int.Int64,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "timeoutInMs" f RunOptions RunOptions a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _RunOptions'timeoutInMs
                 (\ x__ y__ -> x__{_RunOptions'timeoutInMs = y__}))
              Prelude.id

instance (a ~ Data.Int.Int32, b ~ Data.Int.Int32,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "interOpThreadPool" f RunOptions RunOptions a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _RunOptions'interOpThreadPool
                 (\ x__ y__ -> x__{_RunOptions'interOpThreadPool = y__}))
              Prelude.id

instance (a ~ Prelude.Bool, b ~ Prelude.Bool, Prelude.Functor f) =>
         Lens.Labels.HasLens "outputPartitionGraphs" f RunOptions RunOptions
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _RunOptions'outputPartitionGraphs
                 (\ x__ y__ -> x__{_RunOptions'outputPartitionGraphs = y__}))
              Prelude.id

instance (a ~ Proto.Tensorflow.Core.Protobuf.Debug.DebugOptions,
          b ~ Proto.Tensorflow.Core.Protobuf.Debug.DebugOptions,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "debugOptions" f RunOptions RunOptions a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _RunOptions'debugOptions
                 (\ x__ y__ -> x__{_RunOptions'debugOptions = y__}))
              (Data.ProtoLens.maybeLens Data.Default.Class.def)

instance (a ~
            Prelude.Maybe Proto.Tensorflow.Core.Protobuf.Debug.DebugOptions,
          b ~
            Prelude.Maybe Proto.Tensorflow.Core.Protobuf.Debug.DebugOptions,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'debugOptions" f RunOptions RunOptions a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _RunOptions'debugOptions
                 (\ x__ y__ -> x__{_RunOptions'debugOptions = y__}))
              Prelude.id

instance (a ~ Prelude.Bool, b ~ Prelude.Bool, Prelude.Functor f) =>
         Lens.Labels.HasLens "reportTensorAllocationsUponOom" f RunOptions
           RunOptions
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens
                 _RunOptions'reportTensorAllocationsUponOom
                 (\ x__ y__ ->
                    x__{_RunOptions'reportTensorAllocationsUponOom = y__}))
              Prelude.id

instance (a ~ RunOptions'Experimental, b ~ RunOptions'Experimental,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "experimental" f RunOptions RunOptions a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _RunOptions'experimental
                 (\ x__ y__ -> x__{_RunOptions'experimental = y__}))
              (Data.ProtoLens.maybeLens Data.Default.Class.def)

instance (a ~ Prelude.Maybe RunOptions'Experimental,
          b ~ Prelude.Maybe RunOptions'Experimental, Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'experimental" f RunOptions RunOptions a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _RunOptions'experimental
                 (\ x__ y__ -> x__{_RunOptions'experimental = y__}))
              Prelude.id

instance Data.Default.Class.Default RunOptions where
        def
          = RunOptions{_RunOptions'traceLevel = Data.Default.Class.def,
                       _RunOptions'timeoutInMs = Data.ProtoLens.fieldDefault,
                       _RunOptions'interOpThreadPool = Data.ProtoLens.fieldDefault,
                       _RunOptions'outputPartitionGraphs = Data.ProtoLens.fieldDefault,
                       _RunOptions'debugOptions = Prelude.Nothing,
                       _RunOptions'reportTensorAllocationsUponOom =
                         Data.ProtoLens.fieldDefault,
                       _RunOptions'experimental = Prelude.Nothing}

instance Data.ProtoLens.Message RunOptions where
        descriptor
          = let traceLevel__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "trace_level"
                      (Data.ProtoLens.EnumField ::
                         Data.ProtoLens.FieldTypeDescriptor RunOptions'TraceLevel)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional traceLevel)
                      :: Data.ProtoLens.FieldDescriptor RunOptions
                timeoutInMs__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "timeout_in_ms"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional timeoutInMs)
                      :: Data.ProtoLens.FieldDescriptor RunOptions
                interOpThreadPool__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "inter_op_thread_pool"
                      (Data.ProtoLens.Int32Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         interOpThreadPool)
                      :: Data.ProtoLens.FieldDescriptor RunOptions
                outputPartitionGraphs__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "output_partition_graphs"
                      (Data.ProtoLens.BoolField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         outputPartitionGraphs)
                      :: Data.ProtoLens.FieldDescriptor RunOptions
                debugOptions__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "debug_options"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor
                           Proto.Tensorflow.Core.Protobuf.Debug.DebugOptions)
                      (Data.ProtoLens.OptionalField maybe'debugOptions)
                      :: Data.ProtoLens.FieldDescriptor RunOptions
                reportTensorAllocationsUponOom__field_descriptor
                  = Data.ProtoLens.FieldDescriptor
                      "report_tensor_allocations_upon_oom"
                      (Data.ProtoLens.BoolField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         reportTensorAllocationsUponOom)
                      :: Data.ProtoLens.FieldDescriptor RunOptions
                experimental__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "experimental"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor RunOptions'Experimental)
                      (Data.ProtoLens.OptionalField maybe'experimental)
                      :: Data.ProtoLens.FieldDescriptor RunOptions
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.RunOptions")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, traceLevel__field_descriptor),
                    (Data.ProtoLens.Tag 2, timeoutInMs__field_descriptor),
                    (Data.ProtoLens.Tag 3, interOpThreadPool__field_descriptor),
                    (Data.ProtoLens.Tag 5, outputPartitionGraphs__field_descriptor),
                    (Data.ProtoLens.Tag 6, debugOptions__field_descriptor),
                    (Data.ProtoLens.Tag 7,
                     reportTensorAllocationsUponOom__field_descriptor),
                    (Data.ProtoLens.Tag 8, experimental__field_descriptor)])
                (Data.Map.fromList
                   [("trace_level", traceLevel__field_descriptor),
                    ("timeout_in_ms", timeoutInMs__field_descriptor),
                    ("inter_op_thread_pool", interOpThreadPool__field_descriptor),
                    ("output_partition_graphs",
                     outputPartitionGraphs__field_descriptor),
                    ("debug_options", debugOptions__field_descriptor),
                    ("report_tensor_allocations_upon_oom",
                     reportTensorAllocationsUponOom__field_descriptor),
                    ("experimental", experimental__field_descriptor)])

data RunOptions'Experimental = RunOptions'Experimental{_RunOptions'Experimental'collectiveGraphKey
                                                       :: !Data.Int.Int64}
                             deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance (a ~ Data.Int.Int64, b ~ Data.Int.Int64,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "collectiveGraphKey" f RunOptions'Experimental
           RunOptions'Experimental
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens
                 _RunOptions'Experimental'collectiveGraphKey
                 (\ x__ y__ ->
                    x__{_RunOptions'Experimental'collectiveGraphKey = y__}))
              Prelude.id

instance Data.Default.Class.Default RunOptions'Experimental where
        def
          = RunOptions'Experimental{_RunOptions'Experimental'collectiveGraphKey
                                      = Data.ProtoLens.fieldDefault}

instance Data.ProtoLens.Message RunOptions'Experimental where
        descriptor
          = let collectiveGraphKey__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "collective_graph_key"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         collectiveGraphKey)
                      :: Data.ProtoLens.FieldDescriptor RunOptions'Experimental
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.RunOptions.Experimental")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, collectiveGraphKey__field_descriptor)])
                (Data.Map.fromList
                   [("collective_graph_key", collectiveGraphKey__field_descriptor)])

data RunOptions'TraceLevel = RunOptions'NO_TRACE
                           | RunOptions'SOFTWARE_TRACE
                           | RunOptions'HARDWARE_TRACE
                           | RunOptions'FULL_TRACE
                           deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance Data.Default.Class.Default RunOptions'TraceLevel where
        def = RunOptions'NO_TRACE

instance Data.ProtoLens.FieldDefault RunOptions'TraceLevel where
        fieldDefault = RunOptions'NO_TRACE

instance Data.ProtoLens.MessageEnum RunOptions'TraceLevel where
        maybeToEnum 0 = Prelude.Just RunOptions'NO_TRACE
        maybeToEnum 1 = Prelude.Just RunOptions'SOFTWARE_TRACE
        maybeToEnum 2 = Prelude.Just RunOptions'HARDWARE_TRACE
        maybeToEnum 3 = Prelude.Just RunOptions'FULL_TRACE
        maybeToEnum _ = Prelude.Nothing
        showEnum RunOptions'NO_TRACE = "NO_TRACE"
        showEnum RunOptions'SOFTWARE_TRACE = "SOFTWARE_TRACE"
        showEnum RunOptions'HARDWARE_TRACE = "HARDWARE_TRACE"
        showEnum RunOptions'FULL_TRACE = "FULL_TRACE"
        readEnum "NO_TRACE" = Prelude.Just RunOptions'NO_TRACE
        readEnum "SOFTWARE_TRACE" = Prelude.Just RunOptions'SOFTWARE_TRACE
        readEnum "HARDWARE_TRACE" = Prelude.Just RunOptions'HARDWARE_TRACE
        readEnum "FULL_TRACE" = Prelude.Just RunOptions'FULL_TRACE
        readEnum _ = Prelude.Nothing

instance Prelude.Enum RunOptions'TraceLevel where
        toEnum k__
          = Prelude.maybe
              (Prelude.error
                 ((Prelude.++) "toEnum: unknown value for enum TraceLevel: "
                    (Prelude.show k__)))
              Prelude.id
              (Data.ProtoLens.maybeToEnum k__)
        fromEnum RunOptions'NO_TRACE = 0
        fromEnum RunOptions'SOFTWARE_TRACE = 1
        fromEnum RunOptions'HARDWARE_TRACE = 2
        fromEnum RunOptions'FULL_TRACE = 3
        succ RunOptions'FULL_TRACE
          = Prelude.error
              "RunOptions'TraceLevel.succ: bad argument RunOptions'FULL_TRACE. This value would be out of bounds."
        succ RunOptions'NO_TRACE = RunOptions'SOFTWARE_TRACE
        succ RunOptions'SOFTWARE_TRACE = RunOptions'HARDWARE_TRACE
        succ RunOptions'HARDWARE_TRACE = RunOptions'FULL_TRACE
        pred RunOptions'NO_TRACE
          = Prelude.error
              "RunOptions'TraceLevel.pred: bad argument RunOptions'NO_TRACE. This value would be out of bounds."
        pred RunOptions'SOFTWARE_TRACE = RunOptions'NO_TRACE
        pred RunOptions'HARDWARE_TRACE = RunOptions'SOFTWARE_TRACE
        pred RunOptions'FULL_TRACE = RunOptions'HARDWARE_TRACE
        enumFrom = Data.ProtoLens.Message.Enum.messageEnumFrom
        enumFromTo = Data.ProtoLens.Message.Enum.messageEnumFromTo
        enumFromThen = Data.ProtoLens.Message.Enum.messageEnumFromThen
        enumFromThenTo = Data.ProtoLens.Message.Enum.messageEnumFromThenTo

instance Prelude.Bounded RunOptions'TraceLevel where
        minBound = RunOptions'NO_TRACE
        maxBound = RunOptions'FULL_TRACE

data TensorConnection = TensorConnection{_TensorConnection'fromTensor
                                         :: !Data.Text.Text,
                                         _TensorConnection'toTensor :: !Data.Text.Text}
                      deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance (a ~ Data.Text.Text, b ~ Data.Text.Text,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "fromTensor" f TensorConnection
           TensorConnection
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _TensorConnection'fromTensor
                 (\ x__ y__ -> x__{_TensorConnection'fromTensor = y__}))
              Prelude.id

instance (a ~ Data.Text.Text, b ~ Data.Text.Text,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "toTensor" f TensorConnection TensorConnection
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _TensorConnection'toTensor
                 (\ x__ y__ -> x__{_TensorConnection'toTensor = y__}))
              Prelude.id

instance Data.Default.Class.Default TensorConnection where
        def
          = TensorConnection{_TensorConnection'fromTensor =
                               Data.ProtoLens.fieldDefault,
                             _TensorConnection'toTensor = Data.ProtoLens.fieldDefault}

instance Data.ProtoLens.Message TensorConnection where
        descriptor
          = let fromTensor__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "from_tensor"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional fromTensor)
                      :: Data.ProtoLens.FieldDescriptor TensorConnection
                toTensor__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "to_tensor"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional toTensor)
                      :: Data.ProtoLens.FieldDescriptor TensorConnection
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.TensorConnection")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, fromTensor__field_descriptor),
                    (Data.ProtoLens.Tag 2, toTensor__field_descriptor)])
                (Data.Map.fromList
                   [("from_tensor", fromTensor__field_descriptor),
                    ("to_tensor", toTensor__field_descriptor)])

data ThreadPoolOptionProto = ThreadPoolOptionProto{_ThreadPoolOptionProto'numThreads
                                                   :: !Data.Int.Int32,
                                                   _ThreadPoolOptionProto'globalName ::
                                                   !Data.Text.Text}
                           deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance (a ~ Data.Int.Int32, b ~ Data.Int.Int32,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "numThreads" f ThreadPoolOptionProto
           ThreadPoolOptionProto
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _ThreadPoolOptionProto'numThreads
                 (\ x__ y__ -> x__{_ThreadPoolOptionProto'numThreads = y__}))
              Prelude.id

instance (a ~ Data.Text.Text, b ~ Data.Text.Text,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "globalName" f ThreadPoolOptionProto
           ThreadPoolOptionProto
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _ThreadPoolOptionProto'globalName
                 (\ x__ y__ -> x__{_ThreadPoolOptionProto'globalName = y__}))
              Prelude.id

instance Data.Default.Class.Default ThreadPoolOptionProto where
        def
          = ThreadPoolOptionProto{_ThreadPoolOptionProto'numThreads =
                                    Data.ProtoLens.fieldDefault,
                                  _ThreadPoolOptionProto'globalName = Data.ProtoLens.fieldDefault}

instance Data.ProtoLens.Message ThreadPoolOptionProto where
        descriptor
          = let numThreads__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "num_threads"
                      (Data.ProtoLens.Int32Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional numThreads)
                      :: Data.ProtoLens.FieldDescriptor ThreadPoolOptionProto
                globalName__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "global_name"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional globalName)
                      :: Data.ProtoLens.FieldDescriptor ThreadPoolOptionProto
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.ThreadPoolOptionProto")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, numThreads__field_descriptor),
                    (Data.ProtoLens.Tag 2, globalName__field_descriptor)])
                (Data.Map.fromList
                   [("num_threads", numThreads__field_descriptor),
                    ("global_name", globalName__field_descriptor)])

allocatorType ::
              forall f s t a b .
                (Lens.Labels.HasLens "allocatorType" f s t a b) =>
                Lens.Family2.LensLike f s t a b
allocatorType
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "allocatorType")

allowGrowth ::
            forall f s t a b . (Lens.Labels.HasLens "allowGrowth" f s t a b) =>
              Lens.Family2.LensLike f s t a b
allowGrowth
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "allowGrowth")

allowSoftPlacement ::
                   forall f s t a b .
                     (Lens.Labels.HasLens "allowSoftPlacement" f s t a b) =>
                     Lens.Family2.LensLike f s t a b
allowSoftPlacement
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "allowSoftPlacement")

buildCostModel ::
               forall f s t a b .
                 (Lens.Labels.HasLens "buildCostModel" f s t a b) =>
                 Lens.Family2.LensLike f s t a b
buildCostModel
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "buildCostModel")

buildCostModelAfter ::
                    forall f s t a b .
                      (Lens.Labels.HasLens "buildCostModelAfter" f s t a b) =>
                      Lens.Family2.LensLike f s t a b
buildCostModelAfter
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) ::
         (Lens.Labels.Proxy#) "buildCostModelAfter")

clusterDef ::
           forall f s t a b . (Lens.Labels.HasLens "clusterDef" f s t a b) =>
             Lens.Family2.LensLike f s t a b
clusterDef
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "clusterDef")

collectiveGraphKey ::
                   forall f s t a b .
                     (Lens.Labels.HasLens "collectiveGraphKey" f s t a b) =>
                     Lens.Family2.LensLike f s t a b
collectiveGraphKey
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "collectiveGraphKey")

collectiveGroupLeader ::
                      forall f s t a b .
                        (Lens.Labels.HasLens "collectiveGroupLeader" f s t a b) =>
                        Lens.Family2.LensLike f s t a b
collectiveGroupLeader
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) ::
         (Lens.Labels.Proxy#) "collectiveGroupLeader")

costGraph ::
          forall f s t a b . (Lens.Labels.HasLens "costGraph" f s t a b) =>
            Lens.Family2.LensLike f s t a b
costGraph
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "costGraph")

debugOptions ::
             forall f s t a b .
               (Lens.Labels.HasLens "debugOptions" f s t a b) =>
               Lens.Family2.LensLike f s t a b
debugOptions
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "debugOptions")

deferredDeletionBytes ::
                      forall f s t a b .
                        (Lens.Labels.HasLens "deferredDeletionBytes" f s t a b) =>
                        Lens.Family2.LensLike f s t a b
deferredDeletionBytes
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) ::
         (Lens.Labels.Proxy#) "deferredDeletionBytes")

deviceCount ::
            forall f s t a b . (Lens.Labels.HasLens "deviceCount" f s t a b) =>
              Lens.Family2.LensLike f s t a b
deviceCount
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "deviceCount")

deviceFilters ::
              forall f s t a b .
                (Lens.Labels.HasLens "deviceFilters" f s t a b) =>
                Lens.Family2.LensLike f s t a b
deviceFilters
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "deviceFilters")

doCommonSubexpressionElimination ::
                                 forall f s t a b .
                                   (Lens.Labels.HasLens "doCommonSubexpressionElimination" f s t a
                                      b) =>
                                   Lens.Family2.LensLike f s t a b
doCommonSubexpressionElimination
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) ::
         (Lens.Labels.Proxy#) "doCommonSubexpressionElimination")

doConstantFolding ::
                  forall f s t a b .
                    (Lens.Labels.HasLens "doConstantFolding" f s t a b) =>
                    Lens.Family2.LensLike f s t a b
doConstantFolding
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "doConstantFolding")

doFunctionInlining ::
                   forall f s t a b .
                     (Lens.Labels.HasLens "doFunctionInlining" f s t a b) =>
                     Lens.Family2.LensLike f s t a b
doFunctionInlining
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "doFunctionInlining")

enableBfloat16Sendrecv ::
                       forall f s t a b .
                         (Lens.Labels.HasLens "enableBfloat16Sendrecv" f s t a b) =>
                         Lens.Family2.LensLike f s t a b
enableBfloat16Sendrecv
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) ::
         (Lens.Labels.Proxy#) "enableBfloat16Sendrecv")

enableRecvScheduling ::
                     forall f s t a b .
                       (Lens.Labels.HasLens "enableRecvScheduling" f s t a b) =>
                       Lens.Family2.LensLike f s t a b
enableRecvScheduling
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) ::
         (Lens.Labels.Proxy#) "enableRecvScheduling")

experimental ::
             forall f s t a b .
               (Lens.Labels.HasLens "experimental" f s t a b) =>
               Lens.Family2.LensLike f s t a b
experimental
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "experimental")

feed ::
     forall f s t a b . (Lens.Labels.HasLens "feed" f s t a b) =>
       Lens.Family2.LensLike f s t a b
feed
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "feed")

fetch ::
      forall f s t a b . (Lens.Labels.HasLens "fetch" f s t a b) =>
        Lens.Family2.LensLike f s t a b
fetch
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "fetch")

forceGpuCompatible ::
                   forall f s t a b .
                     (Lens.Labels.HasLens "forceGpuCompatible" f s t a b) =>
                     Lens.Family2.LensLike f s t a b
forceGpuCompatible
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "forceGpuCompatible")

fromTensor ::
           forall f s t a b . (Lens.Labels.HasLens "fromTensor" f s t a b) =>
             Lens.Family2.LensLike f s t a b
fromTensor
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "fromTensor")

globalJitLevel ::
               forall f s t a b .
                 (Lens.Labels.HasLens "globalJitLevel" f s t a b) =>
                 Lens.Family2.LensLike f s t a b
globalJitLevel
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "globalJitLevel")

globalName ::
           forall f s t a b . (Lens.Labels.HasLens "globalName" f s t a b) =>
             Lens.Family2.LensLike f s t a b
globalName
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "globalName")

gpuOptions ::
           forall f s t a b . (Lens.Labels.HasLens "gpuOptions" f s t a b) =>
             Lens.Family2.LensLike f s t a b
gpuOptions
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "gpuOptions")

graphOptions ::
             forall f s t a b .
               (Lens.Labels.HasLens "graphOptions" f s t a b) =>
               Lens.Family2.LensLike f s t a b
graphOptions
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "graphOptions")

inferShapes ::
            forall f s t a b . (Lens.Labels.HasLens "inferShapes" f s t a b) =>
              Lens.Family2.LensLike f s t a b
inferShapes
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "inferShapes")

interOpParallelismThreads ::
                          forall f s t a b .
                            (Lens.Labels.HasLens "interOpParallelismThreads" f s t a b) =>
                            Lens.Family2.LensLike f s t a b
interOpParallelismThreads
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) ::
         (Lens.Labels.Proxy#) "interOpParallelismThreads")

interOpThreadPool ::
                  forall f s t a b .
                    (Lens.Labels.HasLens "interOpThreadPool" f s t a b) =>
                    Lens.Family2.LensLike f s t a b
interOpThreadPool
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "interOpThreadPool")

intraOpParallelismThreads ::
                          forall f s t a b .
                            (Lens.Labels.HasLens "intraOpParallelismThreads" f s t a b) =>
                            Lens.Family2.LensLike f s t a b
intraOpParallelismThreads
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) ::
         (Lens.Labels.Proxy#) "intraOpParallelismThreads")

isolateSessionState ::
                    forall f s t a b .
                      (Lens.Labels.HasLens "isolateSessionState" f s t a b) =>
                      Lens.Family2.LensLike f s t a b
isolateSessionState
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) ::
         (Lens.Labels.Proxy#) "isolateSessionState")

key ::
    forall f s t a b . (Lens.Labels.HasLens "key" f s t a b) =>
      Lens.Family2.LensLike f s t a b
key
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "key")

logDevicePlacement ::
                   forall f s t a b .
                     (Lens.Labels.HasLens "logDevicePlacement" f s t a b) =>
                     Lens.Family2.LensLike f s t a b
logDevicePlacement
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "logDevicePlacement")

maxFoldedConstantInBytes ::
                         forall f s t a b .
                           (Lens.Labels.HasLens "maxFoldedConstantInBytes" f s t a b) =>
                           Lens.Family2.LensLike f s t a b
maxFoldedConstantInBytes
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) ::
         (Lens.Labels.Proxy#) "maxFoldedConstantInBytes")

maybe'clusterDef ::
                 forall f s t a b .
                   (Lens.Labels.HasLens "maybe'clusterDef" f s t a b) =>
                   Lens.Family2.LensLike f s t a b
maybe'clusterDef
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'clusterDef")

maybe'costGraph ::
                forall f s t a b .
                  (Lens.Labels.HasLens "maybe'costGraph" f s t a b) =>
                  Lens.Family2.LensLike f s t a b
maybe'costGraph
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'costGraph")

maybe'debugOptions ::
                   forall f s t a b .
                     (Lens.Labels.HasLens "maybe'debugOptions" f s t a b) =>
                     Lens.Family2.LensLike f s t a b
maybe'debugOptions
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'debugOptions")

maybe'experimental ::
                   forall f s t a b .
                     (Lens.Labels.HasLens "maybe'experimental" f s t a b) =>
                     Lens.Family2.LensLike f s t a b
maybe'experimental
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'experimental")

maybe'gpuOptions ::
                 forall f s t a b .
                   (Lens.Labels.HasLens "maybe'gpuOptions" f s t a b) =>
                   Lens.Family2.LensLike f s t a b
maybe'gpuOptions
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'gpuOptions")

maybe'graphOptions ::
                   forall f s t a b .
                     (Lens.Labels.HasLens "maybe'graphOptions" f s t a b) =>
                     Lens.Family2.LensLike f s t a b
maybe'graphOptions
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'graphOptions")

maybe'optimizerOptions ::
                       forall f s t a b .
                         (Lens.Labels.HasLens "maybe'optimizerOptions" f s t a b) =>
                         Lens.Family2.LensLike f s t a b
maybe'optimizerOptions
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) ::
         (Lens.Labels.Proxy#) "maybe'optimizerOptions")

maybe'rewriteOptions ::
                     forall f s t a b .
                       (Lens.Labels.HasLens "maybe'rewriteOptions" f s t a b) =>
                       Lens.Family2.LensLike f s t a b
maybe'rewriteOptions
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) ::
         (Lens.Labels.Proxy#) "maybe'rewriteOptions")

maybe'rpcOptions ::
                 forall f s t a b .
                   (Lens.Labels.HasLens "maybe'rpcOptions" f s t a b) =>
                   Lens.Family2.LensLike f s t a b
maybe'rpcOptions
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'rpcOptions")

maybe'runOptions ::
                 forall f s t a b .
                   (Lens.Labels.HasLens "maybe'runOptions" f s t a b) =>
                   Lens.Family2.LensLike f s t a b
maybe'runOptions
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'runOptions")

maybe'stepStats ::
                forall f s t a b .
                  (Lens.Labels.HasLens "maybe'stepStats" f s t a b) =>
                  Lens.Family2.LensLike f s t a b
maybe'stepStats
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'stepStats")

memoryLimitMb ::
              forall f s t a b .
                (Lens.Labels.HasLens "memoryLimitMb" f s t a b) =>
                Lens.Family2.LensLike f s t a b
memoryLimitMb
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "memoryLimitMb")

numThreads ::
           forall f s t a b . (Lens.Labels.HasLens "numThreads" f s t a b) =>
             Lens.Family2.LensLike f s t a b
numThreads
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "numThreads")

operationTimeoutInMs ::
                     forall f s t a b .
                       (Lens.Labels.HasLens "operationTimeoutInMs" f s t a b) =>
                       Lens.Family2.LensLike f s t a b
operationTimeoutInMs
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) ::
         (Lens.Labels.Proxy#) "operationTimeoutInMs")

optLevel ::
         forall f s t a b . (Lens.Labels.HasLens "optLevel" f s t a b) =>
           Lens.Family2.LensLike f s t a b
optLevel
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "optLevel")

optimizerOptions ::
                 forall f s t a b .
                   (Lens.Labels.HasLens "optimizerOptions" f s t a b) =>
                   Lens.Family2.LensLike f s t a b
optimizerOptions
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "optimizerOptions")

outputPartitionGraphs ::
                      forall f s t a b .
                        (Lens.Labels.HasLens "outputPartitionGraphs" f s t a b) =>
                        Lens.Family2.LensLike f s t a b
outputPartitionGraphs
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) ::
         (Lens.Labels.Proxy#) "outputPartitionGraphs")

partitionGraphs ::
                forall f s t a b .
                  (Lens.Labels.HasLens "partitionGraphs" f s t a b) =>
                  Lens.Family2.LensLike f s t a b
partitionGraphs
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "partitionGraphs")

perProcessGpuMemoryFraction ::
                            forall f s t a b .
                              (Lens.Labels.HasLens "perProcessGpuMemoryFraction" f s t a b) =>
                              Lens.Family2.LensLike f s t a b
perProcessGpuMemoryFraction
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) ::
         (Lens.Labels.Proxy#) "perProcessGpuMemoryFraction")

placePrunedGraph ::
                 forall f s t a b .
                   (Lens.Labels.HasLens "placePrunedGraph" f s t a b) =>
                   Lens.Family2.LensLike f s t a b
placePrunedGraph
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "placePrunedGraph")

placementPeriod ::
                forall f s t a b .
                  (Lens.Labels.HasLens "placementPeriod" f s t a b) =>
                  Lens.Family2.LensLike f s t a b
placementPeriod
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "placementPeriod")

pollingActiveDelayUsecs ::
                        forall f s t a b .
                          (Lens.Labels.HasLens "pollingActiveDelayUsecs" f s t a b) =>
                          Lens.Family2.LensLike f s t a b
pollingActiveDelayUsecs
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) ::
         (Lens.Labels.Proxy#) "pollingActiveDelayUsecs")

pollingInactiveDelayMsecs ::
                          forall f s t a b .
                            (Lens.Labels.HasLens "pollingInactiveDelayMsecs" f s t a b) =>
                            Lens.Family2.LensLike f s t a b
pollingInactiveDelayMsecs
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) ::
         (Lens.Labels.Proxy#) "pollingInactiveDelayMsecs")

reportTensorAllocationsUponOom ::
                               forall f s t a b .
                                 (Lens.Labels.HasLens "reportTensorAllocationsUponOom" f s t a b) =>
                                 Lens.Family2.LensLike f s t a b
reportTensorAllocationsUponOom
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) ::
         (Lens.Labels.Proxy#) "reportTensorAllocationsUponOom")

rewriteOptions ::
               forall f s t a b .
                 (Lens.Labels.HasLens "rewriteOptions" f s t a b) =>
                 Lens.Family2.LensLike f s t a b
rewriteOptions
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "rewriteOptions")

rpcOptions ::
           forall f s t a b . (Lens.Labels.HasLens "rpcOptions" f s t a b) =>
             Lens.Family2.LensLike f s t a b
rpcOptions
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "rpcOptions")

runOptions ::
           forall f s t a b . (Lens.Labels.HasLens "runOptions" f s t a b) =>
             Lens.Family2.LensLike f s t a b
runOptions
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "runOptions")

sessionInterOpThreadPool ::
                         forall f s t a b .
                           (Lens.Labels.HasLens "sessionInterOpThreadPool" f s t a b) =>
                           Lens.Family2.LensLike f s t a b
sessionInterOpThreadPool
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) ::
         (Lens.Labels.Proxy#) "sessionInterOpThreadPool")

stepStats ::
          forall f s t a b . (Lens.Labels.HasLens "stepStats" f s t a b) =>
            Lens.Family2.LensLike f s t a b
stepStats
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "stepStats")

target ::
       forall f s t a b . (Lens.Labels.HasLens "target" f s t a b) =>
         Lens.Family2.LensLike f s t a b
target
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "target")

tensorConnection ::
                 forall f s t a b .
                   (Lens.Labels.HasLens "tensorConnection" f s t a b) =>
                   Lens.Family2.LensLike f s t a b
tensorConnection
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "tensorConnection")

timelineStep ::
             forall f s t a b .
               (Lens.Labels.HasLens "timelineStep" f s t a b) =>
               Lens.Family2.LensLike f s t a b
timelineStep
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "timelineStep")

timeoutInMs ::
            forall f s t a b . (Lens.Labels.HasLens "timeoutInMs" f s t a b) =>
              Lens.Family2.LensLike f s t a b
timeoutInMs
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "timeoutInMs")

toTensor ::
         forall f s t a b . (Lens.Labels.HasLens "toTensor" f s t a b) =>
           Lens.Family2.LensLike f s t a b
toTensor
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "toTensor")

traceLevel ::
           forall f s t a b . (Lens.Labels.HasLens "traceLevel" f s t a b) =>
             Lens.Family2.LensLike f s t a b
traceLevel
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "traceLevel")

usePerSessionThreads ::
                     forall f s t a b .
                       (Lens.Labels.HasLens "usePerSessionThreads" f s t a b) =>
                       Lens.Family2.LensLike f s t a b
usePerSessionThreads
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) ::
         (Lens.Labels.Proxy#) "usePerSessionThreads")

useRpcForInprocessMaster ::
                         forall f s t a b .
                           (Lens.Labels.HasLens "useRpcForInprocessMaster" f s t a b) =>
                           Lens.Family2.LensLike f s t a b
useRpcForInprocessMaster
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) ::
         (Lens.Labels.Proxy#) "useRpcForInprocessMaster")

useUnifiedMemory ::
                 forall f s t a b .
                   (Lens.Labels.HasLens "useUnifiedMemory" f s t a b) =>
                   Lens.Family2.LensLike f s t a b
useUnifiedMemory
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "useUnifiedMemory")

value ::
      forall f s t a b . (Lens.Labels.HasLens "value" f s t a b) =>
        Lens.Family2.LensLike f s t a b
value
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "value")

virtualDevices ::
               forall f s t a b .
                 (Lens.Labels.HasLens "virtualDevices" f s t a b) =>
                 Lens.Family2.LensLike f s t a b
virtualDevices
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "virtualDevices")

visibleDeviceList ::
                  forall f s t a b .
                    (Lens.Labels.HasLens "visibleDeviceList" f s t a b) =>
                    Lens.Family2.LensLike f s t a b
visibleDeviceList
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "visibleDeviceList")