{- This file was auto-generated from tensorflow/core/framework/step_stats.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.Framework.StepStats 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.AllocationDescription
import qualified Proto.Tensorflow.Core.Framework.TensorDescription

data AllocationRecord = AllocationRecord{_AllocationRecord'allocMicros
                                         :: !Data.Int.Int64,
                                         _AllocationRecord'allocBytes :: !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 "allocMicros" f AllocationRecord
           AllocationRecord
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _AllocationRecord'allocMicros
                 (\ x__ y__ -> x__{_AllocationRecord'allocMicros = y__}))
              Prelude.id

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

instance Data.Default.Class.Default AllocationRecord where
        def
          = AllocationRecord{_AllocationRecord'allocMicros =
                               Data.ProtoLens.fieldDefault,
                             _AllocationRecord'allocBytes = Data.ProtoLens.fieldDefault}

instance Data.ProtoLens.Message AllocationRecord where
        descriptor
          = let allocMicros__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "alloc_micros"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional allocMicros)
                      :: Data.ProtoLens.FieldDescriptor AllocationRecord
                allocBytes__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "alloc_bytes"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional allocBytes)
                      :: Data.ProtoLens.FieldDescriptor AllocationRecord
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.AllocationRecord")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, allocMicros__field_descriptor),
                    (Data.ProtoLens.Tag 2, allocBytes__field_descriptor)])
                (Data.Map.fromList
                   [("alloc_micros", allocMicros__field_descriptor),
                    ("alloc_bytes", allocBytes__field_descriptor)])

data AllocatorMemoryUsed = AllocatorMemoryUsed{_AllocatorMemoryUsed'allocatorName
                                               :: !Data.Text.Text,
                                               _AllocatorMemoryUsed'totalBytes :: !Data.Int.Int64,
                                               _AllocatorMemoryUsed'peakBytes :: !Data.Int.Int64,
                                               _AllocatorMemoryUsed'liveBytes :: !Data.Int.Int64,
                                               _AllocatorMemoryUsed'allocationRecords ::
                                               ![AllocationRecord],
                                               _AllocatorMemoryUsed'allocatorBytesInUse ::
                                               !Data.Int.Int64}
                         deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

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

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

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

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

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

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

instance Data.Default.Class.Default AllocatorMemoryUsed where
        def
          = AllocatorMemoryUsed{_AllocatorMemoryUsed'allocatorName =
                                  Data.ProtoLens.fieldDefault,
                                _AllocatorMemoryUsed'totalBytes = Data.ProtoLens.fieldDefault,
                                _AllocatorMemoryUsed'peakBytes = Data.ProtoLens.fieldDefault,
                                _AllocatorMemoryUsed'liveBytes = Data.ProtoLens.fieldDefault,
                                _AllocatorMemoryUsed'allocationRecords = [],
                                _AllocatorMemoryUsed'allocatorBytesInUse =
                                  Data.ProtoLens.fieldDefault}

instance Data.ProtoLens.Message AllocatorMemoryUsed where
        descriptor
          = let allocatorName__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "allocator_name"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional allocatorName)
                      :: Data.ProtoLens.FieldDescriptor AllocatorMemoryUsed
                totalBytes__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "total_bytes"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional totalBytes)
                      :: Data.ProtoLens.FieldDescriptor AllocatorMemoryUsed
                peakBytes__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "peak_bytes"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional peakBytes)
                      :: Data.ProtoLens.FieldDescriptor AllocatorMemoryUsed
                liveBytes__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "live_bytes"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional liveBytes)
                      :: Data.ProtoLens.FieldDescriptor AllocatorMemoryUsed
                allocationRecords__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "allocation_records"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor AllocationRecord)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked
                         allocationRecords)
                      :: Data.ProtoLens.FieldDescriptor AllocatorMemoryUsed
                allocatorBytesInUse__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "allocator_bytes_in_use"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         allocatorBytesInUse)
                      :: Data.ProtoLens.FieldDescriptor AllocatorMemoryUsed
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.AllocatorMemoryUsed")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, allocatorName__field_descriptor),
                    (Data.ProtoLens.Tag 2, totalBytes__field_descriptor),
                    (Data.ProtoLens.Tag 3, peakBytes__field_descriptor),
                    (Data.ProtoLens.Tag 4, liveBytes__field_descriptor),
                    (Data.ProtoLens.Tag 6, allocationRecords__field_descriptor),
                    (Data.ProtoLens.Tag 5, allocatorBytesInUse__field_descriptor)])
                (Data.Map.fromList
                   [("allocator_name", allocatorName__field_descriptor),
                    ("total_bytes", totalBytes__field_descriptor),
                    ("peak_bytes", peakBytes__field_descriptor),
                    ("live_bytes", liveBytes__field_descriptor),
                    ("allocation_records", allocationRecords__field_descriptor),
                    ("allocator_bytes_in_use", allocatorBytesInUse__field_descriptor)])

data DeviceStepStats = DeviceStepStats{_DeviceStepStats'device ::
                                       !Data.Text.Text,
                                       _DeviceStepStats'nodeStats :: ![NodeExecStats]}
                     deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

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

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

instance Data.Default.Class.Default DeviceStepStats where
        def
          = DeviceStepStats{_DeviceStepStats'device =
                              Data.ProtoLens.fieldDefault,
                            _DeviceStepStats'nodeStats = []}

instance Data.ProtoLens.Message DeviceStepStats where
        descriptor
          = let device__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "device"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional device)
                      :: Data.ProtoLens.FieldDescriptor DeviceStepStats
                nodeStats__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "node_stats"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor NodeExecStats)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked nodeStats)
                      :: Data.ProtoLens.FieldDescriptor DeviceStepStats
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.DeviceStepStats")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, device__field_descriptor),
                    (Data.ProtoLens.Tag 2, nodeStats__field_descriptor)])
                (Data.Map.fromList
                   [("device", device__field_descriptor),
                    ("node_stats", nodeStats__field_descriptor)])

data MemoryStats = MemoryStats{_MemoryStats'tempMemorySize ::
                               !Data.Int.Int64,
                               _MemoryStats'persistentMemorySize :: !Data.Int.Int64,
                               _MemoryStats'persistentTensorAllocIds :: ![Data.Int.Int64],
                               _MemoryStats'deviceTempMemorySize :: !Data.Int.Int64,
                               _MemoryStats'devicePersistentMemorySize :: !Data.Int.Int64,
                               _MemoryStats'devicePersistentTensorAllocIds :: ![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 "tempMemorySize" f MemoryStats MemoryStats a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _MemoryStats'tempMemorySize
                 (\ x__ y__ -> x__{_MemoryStats'tempMemorySize = y__}))
              Prelude.id

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

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

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

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

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

instance Data.Default.Class.Default MemoryStats where
        def
          = MemoryStats{_MemoryStats'tempMemorySize =
                          Data.ProtoLens.fieldDefault,
                        _MemoryStats'persistentMemorySize = Data.ProtoLens.fieldDefault,
                        _MemoryStats'persistentTensorAllocIds = [],
                        _MemoryStats'deviceTempMemorySize = Data.ProtoLens.fieldDefault,
                        _MemoryStats'devicePersistentMemorySize =
                          Data.ProtoLens.fieldDefault,
                        _MemoryStats'devicePersistentTensorAllocIds = []}

instance Data.ProtoLens.Message MemoryStats where
        descriptor
          = let tempMemorySize__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "temp_memory_size"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional tempMemorySize)
                      :: Data.ProtoLens.FieldDescriptor MemoryStats
                persistentMemorySize__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "persistent_memory_size"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         persistentMemorySize)
                      :: Data.ProtoLens.FieldDescriptor MemoryStats
                persistentTensorAllocIds__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "persistent_tensor_alloc_ids"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Packed
                         persistentTensorAllocIds)
                      :: Data.ProtoLens.FieldDescriptor MemoryStats
                deviceTempMemorySize__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "device_temp_memory_size"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         deviceTempMemorySize)
                      :: Data.ProtoLens.FieldDescriptor MemoryStats
                devicePersistentMemorySize__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "device_persistent_memory_size"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         devicePersistentMemorySize)
                      :: Data.ProtoLens.FieldDescriptor MemoryStats
                devicePersistentTensorAllocIds__field_descriptor
                  = Data.ProtoLens.FieldDescriptor
                      "device_persistent_tensor_alloc_ids"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Packed
                         devicePersistentTensorAllocIds)
                      :: Data.ProtoLens.FieldDescriptor MemoryStats
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.MemoryStats")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, tempMemorySize__field_descriptor),
                    (Data.ProtoLens.Tag 3, persistentMemorySize__field_descriptor),
                    (Data.ProtoLens.Tag 5, persistentTensorAllocIds__field_descriptor),
                    (Data.ProtoLens.Tag 2, deviceTempMemorySize__field_descriptor),
                    (Data.ProtoLens.Tag 4,
                     devicePersistentMemorySize__field_descriptor),
                    (Data.ProtoLens.Tag 6,
                     devicePersistentTensorAllocIds__field_descriptor)])
                (Data.Map.fromList
                   [("temp_memory_size", tempMemorySize__field_descriptor),
                    ("persistent_memory_size", persistentMemorySize__field_descriptor),
                    ("persistent_tensor_alloc_ids",
                     persistentTensorAllocIds__field_descriptor),
                    ("device_temp_memory_size",
                     deviceTempMemorySize__field_descriptor),
                    ("device_persistent_memory_size",
                     devicePersistentMemorySize__field_descriptor),
                    ("device_persistent_tensor_alloc_ids",
                     devicePersistentTensorAllocIds__field_descriptor)])

data NodeExecStats = NodeExecStats{_NodeExecStats'nodeName ::
                                   !Data.Text.Text,
                                   _NodeExecStats'allStartMicros :: !Data.Int.Int64,
                                   _NodeExecStats'opStartRelMicros :: !Data.Int.Int64,
                                   _NodeExecStats'opEndRelMicros :: !Data.Int.Int64,
                                   _NodeExecStats'allEndRelMicros :: !Data.Int.Int64,
                                   _NodeExecStats'memory :: ![AllocatorMemoryUsed],
                                   _NodeExecStats'output :: ![NodeOutput],
                                   _NodeExecStats'timelineLabel :: !Data.Text.Text,
                                   _NodeExecStats'scheduledMicros :: !Data.Int.Int64,
                                   _NodeExecStats'threadId :: !Data.Word.Word32,
                                   _NodeExecStats'referencedTensor ::
                                   ![Proto.Tensorflow.Core.Framework.AllocationDescription.AllocationDescription],
                                   _NodeExecStats'memoryStats :: !(Prelude.Maybe MemoryStats)}
                   deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

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

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

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

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

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

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

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

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

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

instance (a ~ Data.Word.Word32, b ~ Data.Word.Word32,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "threadId" f NodeExecStats NodeExecStats a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _NodeExecStats'threadId
                 (\ x__ y__ -> x__{_NodeExecStats'threadId = y__}))
              Prelude.id

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

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

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

instance Data.Default.Class.Default NodeExecStats where
        def
          = NodeExecStats{_NodeExecStats'nodeName =
                            Data.ProtoLens.fieldDefault,
                          _NodeExecStats'allStartMicros = Data.ProtoLens.fieldDefault,
                          _NodeExecStats'opStartRelMicros = Data.ProtoLens.fieldDefault,
                          _NodeExecStats'opEndRelMicros = Data.ProtoLens.fieldDefault,
                          _NodeExecStats'allEndRelMicros = Data.ProtoLens.fieldDefault,
                          _NodeExecStats'memory = [], _NodeExecStats'output = [],
                          _NodeExecStats'timelineLabel = Data.ProtoLens.fieldDefault,
                          _NodeExecStats'scheduledMicros = Data.ProtoLens.fieldDefault,
                          _NodeExecStats'threadId = Data.ProtoLens.fieldDefault,
                          _NodeExecStats'referencedTensor = [],
                          _NodeExecStats'memoryStats = Prelude.Nothing}

instance Data.ProtoLens.Message NodeExecStats where
        descriptor
          = let nodeName__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "node_name"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional nodeName)
                      :: Data.ProtoLens.FieldDescriptor NodeExecStats
                allStartMicros__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "all_start_micros"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional allStartMicros)
                      :: Data.ProtoLens.FieldDescriptor NodeExecStats
                opStartRelMicros__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "op_start_rel_micros"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         opStartRelMicros)
                      :: Data.ProtoLens.FieldDescriptor NodeExecStats
                opEndRelMicros__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "op_end_rel_micros"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional opEndRelMicros)
                      :: Data.ProtoLens.FieldDescriptor NodeExecStats
                allEndRelMicros__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "all_end_rel_micros"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional allEndRelMicros)
                      :: Data.ProtoLens.FieldDescriptor NodeExecStats
                memory__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "memory"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor AllocatorMemoryUsed)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked memory)
                      :: Data.ProtoLens.FieldDescriptor NodeExecStats
                output__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "output"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor NodeOutput)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked output)
                      :: Data.ProtoLens.FieldDescriptor NodeExecStats
                timelineLabel__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "timeline_label"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional timelineLabel)
                      :: Data.ProtoLens.FieldDescriptor NodeExecStats
                scheduledMicros__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "scheduled_micros"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional scheduledMicros)
                      :: Data.ProtoLens.FieldDescriptor NodeExecStats
                threadId__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "thread_id"
                      (Data.ProtoLens.UInt32Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Word.Word32)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional threadId)
                      :: Data.ProtoLens.FieldDescriptor NodeExecStats
                referencedTensor__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "referenced_tensor"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor
                           Proto.Tensorflow.Core.Framework.AllocationDescription.AllocationDescription)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked
                         referencedTensor)
                      :: Data.ProtoLens.FieldDescriptor NodeExecStats
                memoryStats__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "memory_stats"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor MemoryStats)
                      (Data.ProtoLens.OptionalField maybe'memoryStats)
                      :: Data.ProtoLens.FieldDescriptor NodeExecStats
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.NodeExecStats")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, nodeName__field_descriptor),
                    (Data.ProtoLens.Tag 2, allStartMicros__field_descriptor),
                    (Data.ProtoLens.Tag 3, opStartRelMicros__field_descriptor),
                    (Data.ProtoLens.Tag 4, opEndRelMicros__field_descriptor),
                    (Data.ProtoLens.Tag 5, allEndRelMicros__field_descriptor),
                    (Data.ProtoLens.Tag 6, memory__field_descriptor),
                    (Data.ProtoLens.Tag 7, output__field_descriptor),
                    (Data.ProtoLens.Tag 8, timelineLabel__field_descriptor),
                    (Data.ProtoLens.Tag 9, scheduledMicros__field_descriptor),
                    (Data.ProtoLens.Tag 10, threadId__field_descriptor),
                    (Data.ProtoLens.Tag 11, referencedTensor__field_descriptor),
                    (Data.ProtoLens.Tag 12, memoryStats__field_descriptor)])
                (Data.Map.fromList
                   [("node_name", nodeName__field_descriptor),
                    ("all_start_micros", allStartMicros__field_descriptor),
                    ("op_start_rel_micros", opStartRelMicros__field_descriptor),
                    ("op_end_rel_micros", opEndRelMicros__field_descriptor),
                    ("all_end_rel_micros", allEndRelMicros__field_descriptor),
                    ("memory", memory__field_descriptor),
                    ("output", output__field_descriptor),
                    ("timeline_label", timelineLabel__field_descriptor),
                    ("scheduled_micros", scheduledMicros__field_descriptor),
                    ("thread_id", threadId__field_descriptor),
                    ("referenced_tensor", referencedTensor__field_descriptor),
                    ("memory_stats", memoryStats__field_descriptor)])

data NodeOutput = NodeOutput{_NodeOutput'slot :: !Data.Int.Int32,
                             _NodeOutput'tensorDescription ::
                             !(Prelude.Maybe
                                 Proto.Tensorflow.Core.Framework.TensorDescription.TensorDescription)}
                deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

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

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

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

instance Data.Default.Class.Default NodeOutput where
        def
          = NodeOutput{_NodeOutput'slot = Data.ProtoLens.fieldDefault,
                       _NodeOutput'tensorDescription = Prelude.Nothing}

instance Data.ProtoLens.Message NodeOutput where
        descriptor
          = let slot__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "slot"
                      (Data.ProtoLens.Int32Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional slot)
                      :: Data.ProtoLens.FieldDescriptor NodeOutput
                tensorDescription__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "tensor_description"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor
                           Proto.Tensorflow.Core.Framework.TensorDescription.TensorDescription)
                      (Data.ProtoLens.OptionalField maybe'tensorDescription)
                      :: Data.ProtoLens.FieldDescriptor NodeOutput
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.NodeOutput")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, slot__field_descriptor),
                    (Data.ProtoLens.Tag 3, tensorDescription__field_descriptor)])
                (Data.Map.fromList
                   [("slot", slot__field_descriptor),
                    ("tensor_description", tensorDescription__field_descriptor)])

data StepStats = StepStats{_StepStats'devStats ::
                           ![DeviceStepStats]}
               deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

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

instance Data.Default.Class.Default StepStats where
        def = StepStats{_StepStats'devStats = []}

instance Data.ProtoLens.Message StepStats where
        descriptor
          = let devStats__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "dev_stats"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor DeviceStepStats)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked devStats)
                      :: Data.ProtoLens.FieldDescriptor StepStats
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.StepStats")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, devStats__field_descriptor)])
                (Data.Map.fromList [("dev_stats", devStats__field_descriptor)])

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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